Move Java backend to properly named folder

chameleon-server/src/main/java/com/chameleonvision/Debug.java

@@ -0,0 +1,19 @@
+package com.chameleonvision;
+
+public class Debug {
+    private Debug() {}
+
+    private static boolean isTestMode() {
+        return Main.testMode;
+    }
+
+    public static void printInfo(String infoMessage) {
+        if (isTestMode()) {
+            System.out.println(infoMessage);
+        }
+    }
+
+    public static void printInfo(String smallInfo, String largeInfo) {
+        System.out.println(isTestMode() ? String.format("%s - %s" , smallInfo, largeInfo) : smallInfo);
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/Main.java

@@ -0,0 +1,167 @@
+package com.chameleonvision;
+
+import com.chameleonvision.config.ConfigManager;
+import com.chameleonvision.network.NetworkManager;
+import com.chameleonvision.util.Platform;
+import com.chameleonvision.util.Utilities;
+import com.chameleonvision.vision.VisionManager;
+import com.chameleonvision.web.Server;
+import edu.wpi.cscore.CameraServerCvJNI;
+import edu.wpi.cscore.CameraServerJNI;
+import edu.wpi.first.networktables.LogMessage;
+import edu.wpi.first.networktables.NetworkTableInstance;
+
+import java.io.IOException;
+import java.util.function.Consumer;
+
+import static com.chameleonvision.util.Platform.CurrentPlatform;
+
+public class Main {
+
+    private static final String NT_SERVERMODE_KEY = "--nt-servermode"; // no args for this setting
+    private static final String NT_CLIENTMODESERVER_KEY = "--nt-client-server"; // expects String representing an IP address (hostnames will be rejected!)
+    private static final String NETWORK_MANAGE_KEY = "--unmanage-network"; // no args for this setting
+    private static final String IGNORE_ROOT_KEY = "--ignore-root"; // no args for this setting
+    private static final String TEST_MODE_KEY = "--cv-development";
+
+    private static final int DEFAULT_PORT = 5800;
+
+    private static boolean ntServerMode = false;
+    private static boolean manageNetwork = true;
+    private static boolean ignoreRoot = false;
+    private static String ntClientModeServer = null;
+    public static boolean testMode = false;
+
+    private static class NTLogger implements Consumer<LogMessage> {
+
+        private boolean hasReportedConnectionFailure = false;
+
+        @Override
+        public void accept(LogMessage logMessage) {
+            if (!hasReportedConnectionFailure && logMessage.message.contains("timed out")) {
+                System.err.println("NT Connection has failed!");
+                hasReportedConnectionFailure = true;
+            }
+        }
+    }
+
+    private static void handleArgs(String[] args) {
+        for (int i = 0; i < args.length; i++) {
+            var key = args[i].toLowerCase();
+            String value = null;
+
+            // this switch handles arguments with a value. Add any settings with a value here.
+            switch (key) {
+                case NT_CLIENTMODESERVER_KEY:
+                    var potentialValue = args[i + 1];
+                    // ensures this "value" isnt null, blank, nor another argument
+                    if (potentialValue != null && !potentialValue.isBlank() && !potentialValue.startsWith("-") & !potentialValue.startsWith("--")) {
+                        value = potentialValue.toLowerCase();
+                    }
+                    i++; // increment to skip an 'arg' next go-around of for loop, as that would be this value
+                    break;
+                case NT_SERVERMODE_KEY:
+                case NETWORK_MANAGE_KEY:
+                case IGNORE_ROOT_KEY:
+                case TEST_MODE_KEY:
+                    // nothing
+                    break;
+            }
+
+            // this switch actually handles the arguments.
+            switch (key) {
+                case NT_SERVERMODE_KEY:
+                    ntServerMode = true;
+                    break;
+                case NT_CLIENTMODESERVER_KEY:
+                    if (value != null) {
+                        if (value.equals("localhost")) {
+                            ntClientModeServer = "127.0.0.1";
+                            continue;
+                        }
+
+                        if (Utilities.isValidIPV4(value)) {
+                            ntClientModeServer = value;
+                            continue;
+                        }
+                    }
+                    System.err.println("Argument for NT Server Host was invalid, defaulting to team number host");
+                    break;
+                case NETWORK_MANAGE_KEY:
+                    manageNetwork = false;
+                    break;
+                case IGNORE_ROOT_KEY:
+                    ignoreRoot = true;
+                    break;
+                case TEST_MODE_KEY:
+                    testMode = true;
+                    break;
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        if (CurrentPlatform.equals(Platform.UNSUPPORTED)) {
+            System.err.printf("Sorry, this platform is not supported. Give these details to the developers.\n%s\n", CurrentPlatform.toString());
+            return;
+        } else {
+            System.out.printf("Starting Chameleon Vision on platform %s\n", CurrentPlatform.toString());
+        }
+
+        handleArgs(args);
+
+        if (!CurrentPlatform.isRoot()) {
+            if (ignoreRoot) {
+                // manageNetwork = false;
+                System.out.println("Ignoring root, network will not be managed!");
+            } else {
+                System.err.println("This program must be run as root!");
+                    return;
+            }
+        }
+
+        // Attempt to load the JNI Libraries
+        try {
+            CameraServerJNI.forceLoad();
+            CameraServerCvJNI.forceLoad();
+        } catch (UnsatisfiedLinkError | IOException e) {
+            if(CurrentPlatform.isWindows()) {
+                System.err.println("Try to download the VC++ Redistributable, https://aka.ms/vs/16/release/vc_redist.x64.exe");
+            }
+            throw new RuntimeException("Failed to load JNI Libraries!");
+        }
+
+        ConfigManager.initializeSettings();
+        NetworkManager.initialize(manageNetwork);
+
+        if (ntServerMode) {
+            System.out.println("Starting NT Server");
+            NetworkTableInstance.getDefault().startServer();
+        } else {
+            NetworkTableInstance.getDefault().addLogger(new NTLogger(), 0, 255); // to hide error messages
+            if (ntClientModeServer != null) {
+                NetworkTableInstance.getDefault().startClient(ntClientModeServer);
+            } else {
+                NetworkTableInstance.getDefault().startClientTeam(ConfigManager.settings.teamNumber);
+            }
+//            NetworkTableInstance.getDefault().startClient("localhost");
+        }
+
+        boolean visionSourcesOk = VisionManager.initializeSources();
+        if (!visionSourcesOk) {
+            System.out.println("No cameras connected!");
+            return;
+        }
+
+        boolean visionProcessesOk = VisionManager.initializeProcesses();
+        if (!visionProcessesOk) {
+            System.err.println("shit");
+            return;
+        }
+
+        VisionManager.startProcesses();
+
+        System.out.printf("Starting Webserver at port %d\n", DEFAULT_PORT);
+        Server.main(DEFAULT_PORT);
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/config/CVPipelineSettingsList.java

@@ -0,0 +1,8 @@
+package com.chameleonvision.config;
+
+import com.chameleonvision.vision.pipeline.CVPipelineSettings;
+
+import java.util.List;
+
+public interface CVPipelineSettingsList extends List<CVPipelineSettings> {
+}

chameleon-server/src/main/java/com/chameleonvision/config/CameraConfig.java

@@ -0,0 +1,139 @@
+package com.chameleonvision.config;
+
+import com.chameleonvision.util.JacksonHelper;
+import com.chameleonvision.vision.pipeline.CVPipelineSettings;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
+
+public class CameraConfig {
+
+    private static final Path camerasConfigFolderPath = Paths.get(ConfigManager.SettingsPath.toString(), "cameras");
+
+    private final String cameraConfigName;
+    private final CameraJsonConfig preliminaryConfig;
+
+    public final PipelineConfig pipelineConfig;
+
+    CameraConfig(CameraJsonConfig config) {
+        preliminaryConfig = config;
+        cameraConfigName = preliminaryConfig.name.replace(' ', '_');
+        pipelineConfig = new PipelineConfig(this);
+    }
+
+    public FullCameraConfiguration load() {
+        checkFolder();
+        checkConfig();
+        checkDriverMode();
+        pipelineConfig.check();
+
+        return new FullCameraConfiguration(loadConfig(), pipelineConfig.load(), loadDriverMode(), this);
+    }
+
+    private CameraJsonConfig loadConfig() {
+        CameraJsonConfig config = preliminaryConfig;
+        try {
+            config = JacksonHelper.deserializer(getConfigPath(), CameraJsonConfig.class);
+        } catch (IOException e) {
+            System.err.printf("Failed to load camera config: %s - using default.\n", getConfigPath().toString());
+        }
+        return config;
+    }
+
+    private CVPipelineSettings loadDriverMode() {
+        CVPipelineSettings driverMode = new CVPipelineSettings();
+        driverMode.nickname = "DRIVERMODE";
+        try {
+            driverMode = JacksonHelper.deserializer(getDriverModePath(), CVPipelineSettings.class);
+        } catch (IOException e) {
+            System.err.println("Failed to load camera drivermode: " + getDriverModePath().toString());
+        }
+        return driverMode;
+    }
+
+    void saveConfig(CameraJsonConfig config) {
+        try {
+            JacksonHelper.serializer(getConfigPath(), config);
+        } catch (IOException e) {
+            System.err.println("Failed to save camera config file: " + getConfigPath().toString());
+        }
+    }
+
+    void savePipelines(List<CVPipelineSettings> pipelines) {
+        pipelineConfig.save(pipelines);
+    }
+
+    public void saveDriverMode(CVPipelineSettings driverMode) {
+        try {
+            JacksonHelper.serializer(getDriverModePath(), driverMode);
+        } catch (IOException e) {
+            System.err.println("Failed to save camera drivermode file: " + getDriverModePath().toString());
+        }
+    }
+
+    void checkFolder() {
+        if (!getConfigFolderExists()) {
+            try {
+                if (!(new File(getConfigFolderPath().toUri()).mkdirs())) {
+                    System.err.println("Failed to create camera config folder: " + getConfigFolderPath().toString());
+                }
+            } catch(Exception e) {
+                System.err.println("Failed to create camera config folder: " + getConfigFolderPath().toString());
+            }
+        }
+    }
+
+    private void checkConfig() {
+        if (!configExists()) {
+            try {
+                JacksonHelper.serializer(getConfigPath(), preliminaryConfig);
+            } catch (IOException e) {
+                System.err.println("Failed to create camera config file: " + getConfigPath().toString());
+            }
+        }
+    }
+
+    private void checkDriverMode() {
+        if (!driverModeExists()) {
+            try {
+                CVPipelineSettings newDriverModeSettings = new CVPipelineSettings();
+                newDriverModeSettings.nickname = "DRIVERMODE";
+                JacksonHelper.serializer(getDriverModePath(), newDriverModeSettings);
+            } catch (IOException e) {
+                System.err.println("Failed to create camera drivermode file: " + getDriverModePath().toString());
+            }
+        }
+    }
+
+    private Path getConfigFolderPath() {
+        return Paths.get(camerasConfigFolderPath.toString(), cameraConfigName);
+    }
+
+    private Path getConfigPath() {
+        return Paths.get(getConfigFolderPath().toString(), "camera.json");
+    }
+
+    private Path getDriverModePath() {
+        return Paths.get(getConfigFolderPath().toString(), "drivermode.json");
+    }
+
+    private boolean getConfigFolderExists() {
+        return Files.exists(getConfigFolderPath());
+    }
+
+    Path getPipelineFolderPath() {
+        return Paths.get(getConfigFolderPath().toString(), "pipelines");
+    }
+
+    private boolean configExists() {
+        return getConfigFolderExists() && Files.exists(getConfigPath());
+    }
+
+    private boolean driverModeExists() {
+        return getConfigFolderExists() && Files.exists(getDriverModePath());
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/config/CameraJsonConfig.java

@@ -0,0 +1,48 @@
+package com.chameleonvision.config;
+
+import com.chameleonvision.vision.VisionProcess;
+import com.chameleonvision.vision.camera.USBCameraProperties;
+import com.chameleonvision.vision.enums.StreamDivisor;
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+public class CameraJsonConfig {
+    public final double fov;
+    public final String path;
+    public final String name;
+    public final String nickname;
+    public final int videomode;
+    public final StreamDivisor streamDivisor;
+
+    @JsonCreator
+    public CameraJsonConfig(
+            @JsonProperty("fov") double fov,
+            @JsonProperty("path") String path,
+            @JsonProperty("name") String name,
+            @JsonProperty("nickname") String nickname,
+            @JsonProperty("videomode") int videomode,
+            @JsonProperty("streamDivisor") StreamDivisor streamDivisor) {
+        this.fov = fov;
+        this.path = path;
+        this.name = name;
+        this.nickname = nickname;
+        this.videomode = videomode;
+        this.streamDivisor = streamDivisor;
+    }
+
+    public CameraJsonConfig(String path, String name) {
+        this.fov = USBCameraProperties.DEFAULT_FOV;
+        this.path = path;
+        this.name = name;
+        this.nickname = name;
+        this.videomode = 0;
+        this.streamDivisor = StreamDivisor.NONE;
+    }
+
+    public static CameraJsonConfig fromVisionProcess(VisionProcess process) {
+        USBCameraProperties camProps = process.getCamera().getProperties();
+        int videomode = camProps.getCurrentVideoModeIndex();
+        StreamDivisor streamDivisor = process.cameraStreamer.getDivisor();
+        return new CameraJsonConfig(camProps.getFOV(), camProps.path, camProps.name, camProps.getNickname(), videomode, streamDivisor);
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/config/ConfigManager.java

@@ -0,0 +1,111 @@
+package com.chameleonvision.config;
+
+import com.chameleonvision.util.ProgramDirectoryUtilities;
+import com.chameleonvision.util.JacksonHelper;
+import com.chameleonvision.vision.pipeline.CVPipelineSettings;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+
+public class ConfigManager {
+    private ConfigManager() {}
+
+    static final Path SettingsPath = Paths.get(ProgramDirectoryUtilities.getProgramDirectory(), "settings");
+    private static final Path settingsFilePath = Paths.get(SettingsPath.toString(), "settings.json");
+
+    private static final LinkedHashMap<String, CameraConfig> cameraConfigs = new LinkedHashMap<>();
+
+    public static GeneralSettings settings = new GeneralSettings();
+
+    private static boolean settingsFolderExists() { return Files.exists(SettingsPath); }
+    private static boolean settingsFileExists() { return settingsFolderExists() && Files.exists(settingsFilePath); }
+
+    private static void checkSettingsFolder() {
+        if (!settingsFolderExists()) {
+            try {
+                if( !(new File(SettingsPath.toUri()).mkdirs()) ) {
+                    System.err.println("Failed to create settings folder: " + SettingsPath.toString());
+                }
+                Files.createDirectory(SettingsPath);
+            } catch (IOException e) {
+                if(!(e instanceof java.nio.file.FileAlreadyExistsException))
+                    e.printStackTrace();
+            }
+        }
+    }
+
+    private static void checkSettingsFile() {
+        boolean settingsFileEmpty = settingsFileExists() && new File(settingsFilePath.toString()).length() == 0;
+        if (settingsFileEmpty || !settingsFileExists()) {
+            try {
+                JacksonHelper.serializer(settingsFilePath, settings);
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        } else {
+            try {
+                settings = JacksonHelper.deserializer(settingsFilePath, GeneralSettings.class);
+            } catch (IOException e) {
+                System.err.println("Failed to load settings.json, using defaults.");
+            }
+        }
+    }
+
+    public static void initializeSettings() {
+        System.out.println("Settings folder: " + SettingsPath.toString());
+        checkSettingsFolder();
+        checkSettingsFile();
+    }
+
+    private static void saveSettingsFile() {
+        try {
+            JacksonHelper.serializer(settingsFilePath, settings);
+        } catch (IOException e) {
+            System.err.println("Failed to save settings.json!");
+        }
+    }
+
+    public static void saveGeneralSettings() {
+        checkSettingsFolder();
+        saveSettingsFile();
+    }
+
+    public static List<FullCameraConfiguration> initializeCameras(List<CameraJsonConfig> preliminaryConfigs) {
+        List<FullCameraConfiguration> configList = new ArrayList<>();
+
+        checkSettingsFolder();
+
+        // loop over all the camera names and try to create settings folders for it
+        for (CameraJsonConfig preliminaryConfig : preliminaryConfigs) {
+            CameraConfig cameraConfiguration = new CameraConfig(preliminaryConfig);
+            cameraConfigs.put(preliminaryConfig.name, cameraConfiguration);
+
+            FullCameraConfiguration camJsonConfig = cameraConfiguration.load();
+
+            configList.add(camJsonConfig);
+        }
+
+        return configList;
+    }
+
+    public static void saveCameraConfig(String cameraName, CameraJsonConfig config) {
+        var camConf = cameraConfigs.get(cameraName);
+        camConf.saveConfig(config);
+    }
+
+    public static void saveCameraPipelines(String cameraName, List<CVPipelineSettings> pipelines) {
+        var camConf = cameraConfigs.get(cameraName);
+        camConf.savePipelines(pipelines);
+    }
+
+    public static void saveCameraDriverMode(String cameraName, CVPipelineSettings driverMode) {
+        var camConf = cameraConfigs.get(cameraName);
+        camConf.saveDriverMode(driverMode);
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/config/FullCameraConfiguration.java

@@ -0,0 +1,19 @@
+package com.chameleonvision.config;
+
+import com.chameleonvision.vision.pipeline.CVPipelineSettings;
+
+import java.util.List;
+
+public class FullCameraConfiguration {
+    public final CameraJsonConfig cameraConfig;
+    public final List<CVPipelineSettings> pipelines;
+    public final CVPipelineSettings drivermode;
+    public final CameraConfig fileConfig;
+
+    FullCameraConfiguration(CameraJsonConfig cameraConfig, List<CVPipelineSettings> pipelines, CVPipelineSettings drivermode, CameraConfig fileConfig) {
+        this.cameraConfig = cameraConfig;
+        this.pipelines = pipelines;
+        this.drivermode = drivermode;
+        this.fileConfig = fileConfig;
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/config/GeneralSettings.java

@@ -0,0 +1,14 @@
+package com.chameleonvision.config;
+
+import com.chameleonvision.network.NetworkIPMode;
+
+public class GeneralSettings {
+	public int teamNumber = 1577;
+	public NetworkIPMode connectionType = NetworkIPMode.DHCP;
+	public String ip = "";
+	public String gateway = "";
+	public String netmask = "";
+	public String hostname = "Chameleon-vision";
+	public String currentCamera = "";
+	public Integer currentPipeline = null;
+}

chameleon-server/src/main/java/com/chameleonvision/config/PipelineConfig.java

@@ -0,0 +1,150 @@
+package com.chameleonvision.config;
+
+import com.chameleonvision.util.JacksonHelper;
+import com.chameleonvision.vision.pipeline.*;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+
+public class PipelineConfig {
+
+    private static final String CVPipeline2DPrefix = "CV2D";
+    private static final String CVPipeline3DPrefix = "CV3D";
+
+    private final CameraConfig cameraConfig;
+
+    /**
+     * Construct a new PipelineConfig
+     * @param cameraConfig the CameraConfig (parent folder, kinda?)
+     */
+    PipelineConfig(CameraConfig cameraConfig) {
+        this.cameraConfig = cameraConfig;
+    }
+
+    private void checkFolder() {
+        if ( !(new File(cameraConfig.getPipelineFolderPath().toUri()).mkdirs())) {
+            if (Files.notExists(cameraConfig.getPipelineFolderPath())) {
+                System.err.println("Failed to create pipelines folder.");
+            }
+        }
+    }
+
+    private File[] getPipelineFiles() {
+        return new File(cameraConfig.getPipelineFolderPath().toUri()).listFiles();
+    }
+
+    private boolean folderHasPipelines() {
+        File[] folderContents = getPipelineFiles();
+        if(folderContents == null) return false;
+        return folderContents.length > 0;
+    }
+
+    void check() {
+        cameraConfig.checkFolder();
+        checkFolder();
+        // Check if there's at least one pipe
+        if (!folderHasPipelines()) {
+            save(new CVPipeline2dSettings());
+        }
+    }
+
+    private Path getPipelinePath(CVPipelineSettings setting) {
+        String pipelineName = setting.nickname.replace(' ', '_');
+        String prefix = ((setting instanceof CVPipeline2dSettings) ? CVPipeline2DPrefix : CVPipeline3DPrefix) + "-";
+        String fullFileName = prefix + pipelineName + ".json";
+        return Path.of(cameraConfig.getPipelineFolderPath().toString(), fullFileName);
+    }
+
+    private boolean pipelineExists(CVPipelineSettings setting) {
+        return Files.exists(getPipelinePath(setting));
+    }
+
+    public void save(CVPipelineSettings settings) {
+
+        var path = getPipelinePath(settings);
+
+        if (settings instanceof CVPipeline3dSettings) {
+            try {
+                JacksonHelper.serializer(path, settings);
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        } else if (settings instanceof CVPipeline2dSettings) {
+            try {
+                JacksonHelper.serializer(path, settings);
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        } else {
+            throw new RuntimeException("saving non-2d and non-3d pipelines not implemented~");
+        }
+    }
+
+    public void save(List<CVPipelineSettings> settings) {
+        for(CVPipelineSettings setting : settings) {
+            save(setting);
+        }
+    }
+
+    public void delete(CVPipelineSettings setting) {
+        if(pipelineExists(setting)) {
+            try {
+                Files.delete(getPipelinePath(setting));
+            } catch (IOException e) {
+                System.err.println("Failed to delete pipeline!");
+            }
+        }
+    }
+
+    public CVPipelineSettings rename(CVPipelineSettings setting, String newName) {
+        if (pipelineExists(setting)) {
+            delete(setting);
+            setting.nickname = newName;
+            save(setting);
+        } else {
+            setting.nickname = newName;
+            save(setting);
+        }
+        return setting;
+    }
+
+    public List<CVPipelineSettings> load() {
+        check(); // TODO: this ensures there will be a default pipeline. is the check later necessary?
+
+        File[] pipelineFiles = getPipelineFiles();
+        List<CVPipelineSettings> deserializedList = new ArrayList<>();
+
+        if(pipelineFiles == null || pipelineFiles.length < 1) {
+            // TODO handle no pipelines to load
+            System.err.println("no pipes to load! loading default");
+        } else {
+            for(File pipelineFile : pipelineFiles) {
+                var name = pipelineFile.getName();
+                if(name.startsWith(CVPipeline3DPrefix)) {
+                    // try to load 3d pipe
+                    try {
+                        var pipe = JacksonHelper.deserializer(Paths.get(pipelineFile.getPath()), CVPipeline3dSettings.class);
+                        deserializedList.add(pipe);
+                    } catch (IOException e) {
+                        System.err.println("couldn't load cvpipeline3d");
+                    }
+                } else if(name.startsWith(CVPipeline2DPrefix)) {
+                    // try to load 2d pipe
+                    try {
+                        var pipe = JacksonHelper.deserializer(Paths.get(pipelineFile.getPath()), CVPipeline2dSettings.class);
+                        deserializedList.add(pipe);
+                    } catch (IOException e) {
+                        System.err.println("couldn't load cvpipeline2d");
+                    }
+                }
+            }
+        }
+
+        return deserializedList;
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/network/LinuxNetworking.java

@@ -0,0 +1,73 @@
+package com.chameleonvision.network;
+
+import java.io.IOException;
+import java.net.SocketException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class LinuxNetworking extends SysNetworking {
+
+	@Override
+	public boolean setDHCP() {
+		String[] clearArgs = { "addr", "flush", "dev", networkInterface.name };
+		try {
+			int clearRetCode = shell.execute("ip", clearArgs);
+			int dhcpRetCode = shell.execute("dhclient", networkInterface.name);
+			return clearRetCode == 0 && dhcpRetCode == 0;
+		} catch (IOException e) {
+			e.printStackTrace();
+			return false;
+		}
+	}
+
+	@Override
+	public boolean setHostname(String newHostname) {
+		String[] setHostnameArgs = { "set-hostname", newHostname };
+		try {
+			var setHostnameRetCode = shell.execute("hostnamectl", setHostnameArgs);
+			return setHostnameRetCode == 0;
+		} catch(Exception e)  {
+			e.printStackTrace();
+			return false;
+		}
+	}
+
+	@Override
+	public boolean setStatic(String ipAddress, String netmask, String gateway, String broadcast) {
+		try {
+			String[] clearArgs = { "addr", "flush", "dev", networkInterface.name };
+			String[] setIPArgs = { "addr", "add", String.format("%s/%s", ipAddress, netmask), "broadcast", broadcast, "dev", networkInterface.name };
+			String[] setGatewayArgs = { "route", "replace", "default", "via", gateway, "dev", networkInterface.name };
+
+			int clearRetCode = shell.execute("ip", clearArgs);
+			int setIPRetCode = shell.execute("ip", setIPArgs);
+			int setGatewayRetCode = shell.execute("ip", setGatewayArgs);
+
+			return clearRetCode == 0 && setIPRetCode == 0 && setGatewayRetCode == 0;
+		} catch (IOException e) {
+			e.printStackTrace();
+			return false;
+		}
+	}
+
+	@Override
+	public List<java.net.NetworkInterface> getNetworkInterfaces() throws SocketException {
+		List<java.net.NetworkInterface> netInterfaces;
+		try {
+			netInterfaces = Collections.list(java.net.NetworkInterface.getNetworkInterfaces());
+		} catch (SocketException e) {
+			return null;
+		}
+
+		List<java.net.NetworkInterface> goodInterfaces = new ArrayList<>();
+
+		for (var netInterface : netInterfaces) {
+		    if (netInterface.getDisplayName().contains("lo")) continue;
+			if (!netInterface.isUp()) continue;
+			goodInterfaces.add(netInterface);
+		}
+		return goodInterfaces;
+
+	}
+}

chameleon-server/src/main/java/com/chameleonvision/network/NetworkIPMode.java

@@ -0,0 +1,7 @@
+package com.chameleonvision.network;
+
+public enum NetworkIPMode {
+	DHCP,
+	STATIC,
+	UNKNOWN
+}

chameleon-server/src/main/java/com/chameleonvision/network/NetworkInterface.java

@@ -0,0 +1,54 @@
+package com.chameleonvision.network;
+
+import java.net.InterfaceAddress;
+
+@SuppressWarnings("WeakerAccess")
+public class NetworkInterface {
+	public final String name;
+	public final String displayName;
+	public final String IPAddress;
+	public final String Netmask;
+	public final String Gateway;
+	public final String Broadcast;
+
+	public NetworkInterface(java.net.NetworkInterface inetface, InterfaceAddress ifaceAddress) {
+		name = inetface.getName();
+		displayName = inetface.getDisplayName();
+
+		var inetAddress = ifaceAddress.getAddress();
+		IPAddress = inetAddress.getHostAddress();
+        Netmask = getIPv4LocalNetMask(ifaceAddress);
+
+        // TODO: (low) hack to "get" gateway, this is gross and bad, pls fix
+        var splitIPAddr = IPAddress.split("\\.");
+        splitIPAddr[3] = "1";
+        Gateway = String.join(".", splitIPAddr);
+        splitIPAddr[3] = "255";
+        Broadcast = String.join(".", splitIPAddr);
+	}
+
+    private static String getIPv4LocalNetMask(InterfaceAddress interfaceAddress) {
+	    var netPrefix = interfaceAddress.getNetworkPrefixLength();
+        try {
+            // Since this is for IPv4, it's 32 bits, so set the sign value of
+            // the int to "negative"...
+            int shiftby = (1<<31);
+            // For the number of bits of the prefix -1 (we already set the sign bit)
+            for (int i = netPrefix - 1; i > 0; i--) {
+                // Shift the sign right... Java makes the sign bit sticky on a shift...
+                // So no need to "set it back up"...
+                shiftby = (shiftby >> 1);
+            }
+            // Transform the resulting value in xxx.xxx.xxx.xxx format, like if
+            /// it was a standard address...
+	        // Return the address thus created...
+            return ((shiftby >> 24) & 255) + "." + ((shiftby >> 16) & 255) + "." + ((shiftby >> 8) & 255) + "." + (shiftby & 255);
+//            return InetAddress.getByName(maskString);
+        }
+        catch(Exception e) {
+            e.printStackTrace();
+        }
+        // Something went wrong here...
+        return null;
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/network/NetworkManager.java

@@ -0,0 +1,127 @@
+package com.chameleonvision.network;
+
+
+import com.chameleonvision.config.ConfigManager;
+import com.chameleonvision.util.Platform;
+
+import java.net.SocketException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class NetworkManager {
+	private NetworkManager() {}
+
+	private static SysNetworking networking;
+	private static boolean isManaged = false;
+
+	public static void initialize(boolean manage) {
+		isManaged = manage;
+		if (!isManaged) {
+			return;
+		}
+
+		Platform platform = Platform.getCurrentPlatform();
+
+		if (platform.isLinux()) {
+			networking = new LinuxNetworking();
+		} else if (platform.isWindows()) {
+//			networking = new WindowsNetworking();
+            System.out.println("Windows networking is not yet supported. Running unmanaged.");
+            return;
+		}
+
+		if (networking == null) {
+			throw new RuntimeException("Failed to detect platform!");
+		}
+
+		List<java.net.NetworkInterface> interfaces = new ArrayList<>();
+		List<NetworkInterface> goodInterfaces = new ArrayList<>();
+
+		try {
+			interfaces = networking.getNetworkInterfaces();
+		} catch (SocketException e) {
+			e.printStackTrace();
+		}
+
+        var teamBytes = NetworkManager.GetTeamNumberIPBytes(ConfigManager.settings.teamNumber);
+
+        if (interfaces.size() > 0) {
+			for (var inetface : interfaces) {
+                for (var inetfaceAddr : inetface.getInterfaceAddresses()) {
+                    var rawAddr = inetfaceAddr.getAddress().getAddress();
+                    if (rawAddr.length > 4) continue;
+                    if (rawAddr[1] == teamBytes[0] && rawAddr[2] == teamBytes[1]) {
+                        goodInterfaces.add(new NetworkInterface(inetface, inetfaceAddr));
+                    }
+                }
+			}
+
+			if (goodInterfaces.size() == 0) {
+				isManaged = false;
+				System.err.println("No valid network interfaces found! Staying unmanaged.");
+				return;
+			}
+
+	        NetworkInterface botInterface = goodInterfaces.get(0);
+			networking.setNetworkInterface(botInterface);
+		} else {
+        	isManaged = false;
+			System.err.println("No valid network interfaces found! Staying unmanaged.");
+			return;
+		}
+
+		if(!loadFromGeneralSettings()) {
+			isManaged = false;
+			System.err.println("Failed to load network settings. Staying unmanaged!");
+		}
+	}
+
+	private static byte[] GetTeamNumberIPBytes(int teamNumber) {
+		return new byte[]{(byte) (teamNumber / 100), (byte) (teamNumber % 100)};
+	}
+
+	private static boolean loadFromGeneralSettings() {
+		if (!isManaged) {
+			return true;
+		}
+
+		var genSettings = ConfigManager.settings;
+		boolean isStatic = genSettings.connectionType.equals(NetworkIPMode.STATIC);
+
+		if (isStatic) {
+			var splitIPAddr = genSettings.ip.split("\\.");
+			splitIPAddr[3] = "255";
+			var broadcast = String.join(".", splitIPAddr);
+			if (!setStatic(genSettings.ip, genSettings.netmask, genSettings.gateway, broadcast)) {
+				return false;
+			}
+		} else {
+			if (!setDHCP()) {
+				return false;
+			}
+		}
+
+		return setHostname(genSettings.hostname);
+	}
+
+	private static boolean setDHCP() {
+		if (!isManaged) {
+			return true;
+		}
+	    return networking.setDHCP();
+    }
+
+    private static boolean setStatic(String ipAddress, String netmask, String gateway, String broadcast) {
+		if (!isManaged) {
+			return true;
+		}
+	    return networking.setStatic(ipAddress, netmask, gateway, broadcast);
+    }
+
+    private static boolean setHostname(String hostname) {
+		if (!isManaged) {
+			return true;
+		}
+	    return networking.setHostname(hostname);
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/network/SysNetworking.java

@@ -0,0 +1,36 @@
+package com.chameleonvision.network;
+
+import com.chameleonvision.util.ShellExec;
+
+import java.io.IOException;
+import java.net.SocketException;
+import java.util.List;
+
+public abstract class SysNetworking {
+
+	NetworkInterface networkInterface;
+	ShellExec shell = new ShellExec(true, true);
+
+	public String getHostname() {
+		try {
+			var retCode = shell.execute("hostname", null, true);
+			if (retCode == 0) {
+				while(!shell.isOutputCompleted()) {}
+				return shell.getOutput();
+			} else {
+				return null;
+			}
+		} catch (IOException e) {
+			return null;
+		}
+	}
+
+	public void setNetworkInterface(NetworkInterface networkInterface) {
+		this.networkInterface = networkInterface;
+	}
+	public abstract boolean setDHCP();
+	public abstract boolean setHostname(String hostname);
+	public abstract boolean setStatic(String ipAddress, String netmask, String gateway, String broadcast);
+	public abstract List<java.net.NetworkInterface> getNetworkInterfaces() throws SocketException;
+
+}

chameleon-server/src/main/java/com/chameleonvision/network/WindowsNetworking.java

@@ -0,0 +1,54 @@
+package com.chameleonvision.network;
+
+import java.net.SocketException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class WindowsNetworking extends SysNetworking {
+
+	@Override
+	public boolean setDHCP() {
+		return false;
+	}
+
+	@Override
+	public boolean setHostname(String newHostname) {
+		var currentHostname = getHostname();
+
+		if (getHostname() == null) {
+			return false;
+		}
+
+		String command = String.format("wmic computersystem where name=\"%s\" call rename name=\"%s\"", currentHostname, newHostname);
+
+		try {
+			var process = Runtime.getRuntime().exec(command);
+			var returnCode = process.waitFor();
+			return returnCode == 0;
+		} catch(Exception e)  {
+			return false;
+		}
+	}
+
+	@Override
+	public boolean setStatic(String ipAddress, String netmask, String gateway, String broadcast) {
+		return false;
+	}
+
+	@Override
+	public List<java.net.NetworkInterface> getNetworkInterfaces() throws SocketException {
+		var netInterfaces = Collections.list(java.net.NetworkInterface.getNetworkInterfaces());
+
+		List<java.net.NetworkInterface> goodInterfaces = new ArrayList<>();
+
+		for (var netInterface : netInterfaces) {
+			if (netInterface.getDisplayName().toLowerCase().contains("bluetooth")) continue;
+			if (netInterface.getDisplayName().toLowerCase().contains("virtual")) continue;
+			if (netInterface.getDisplayName().toLowerCase().contains("loopback")) continue;
+			if (!netInterface.isUp()) continue;
+			goodInterfaces.add(netInterface);
+		}
+		return goodInterfaces;
+	}
+}

chameleon-server/src/main/java/com/chameleonvision/util/Helpers.java

@@ -0,0 +1,25 @@
+package com.chameleonvision.util;
+
+import edu.wpi.cscore.VideoMode;
+import org.opencv.core.Scalar;
+
+import java.awt.*;
+import java.util.HashMap;
+import java.util.Map;
+
+public class Helpers {
+    private Helpers() {
+    }
+
+    public static Scalar colorToScalar(Color color) {
+        return new Scalar(color.getRed(), color.getGreen(), color.getBlue());
+    }
+
+    public static HashMap VideoModeToHashMap(VideoMode videoMode) {
+        return new HashMap<String, Object>() {{
+                put("width", videoMode.width);
+                put("height", videoMode.height);
+                put("fps", videoMode.fps);
+                put("pixelFormat", videoMode.pixelFormat.toString());}};
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/util/JacksonHelper.java

@@ -0,0 +1,30 @@
+package com.chameleonvision.util;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.json.JsonMapper;
+import com.fasterxml.jackson.databind.jsontype.BasicPolymorphicTypeValidator;
+import com.fasterxml.jackson.databind.jsontype.PolymorphicTypeValidator;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+public class JacksonHelper {
+    private JacksonHelper() {} // no construction, utility class
+
+    public static <T> void serializer(Path path, T object) throws IOException {
+        PolymorphicTypeValidator ptv = BasicPolymorphicTypeValidator.builder().allowIfBaseType(object.getClass()).build();
+        ObjectMapper objectMapper = JsonMapper.builder().activateDefaultTyping(ptv, ObjectMapper.DefaultTyping.JAVA_LANG_OBJECT).build();
+        objectMapper.writerWithDefaultPrettyPrinter().writeValue(new File(path.toString()), object);
+    }
+
+    public static <T> T deserializer(Path path, Class<T> ref) throws IOException {
+        PolymorphicTypeValidator ptv = BasicPolymorphicTypeValidator.builder().allowIfBaseType(ref).build();
+        ObjectMapper objectMapper = JsonMapper.builder().activateDefaultTyping(ptv, ObjectMapper.DefaultTyping.JAVA_LANG_OBJECT).build();
+        File jsonFile = new File(path.toString());
+        if (jsonFile.exists() && jsonFile.length() > 0) {
+            return objectMapper.readValue(jsonFile, ref);
+        }
+        return null;
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/util/LoopingRunnable.java

@@ -0,0 +1,37 @@
+package com.chameleonvision.util;
+
+/**
+ * A thread that tries to run at a specified loop time
+ */
+public abstract class LoopingRunnable implements Runnable {
+    protected volatile Long loopTimeMs;
+
+    protected abstract void process();
+
+    public LoopingRunnable(Long loopTimeMs) {
+        this.loopTimeMs = loopTimeMs;
+    }
+
+    @Override
+    public void run() {
+        while(!Thread.interrupted()) {
+            var now = System.currentTimeMillis();
+
+            // Do the thing
+            process();
+
+            // sleep for the remaining time
+            var timeElapsed = System.currentTimeMillis() - now;
+            var delta = loopTimeMs - timeElapsed;
+            try {
+                if(delta > 0.0) {
+
+                    Thread.sleep(delta, 0);
+
+                } else {
+                    Thread.sleep(1);
+                }
+            } catch (Exception ignored) {}
+        }
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/util/MathHandler.java

@@ -0,0 +1,27 @@
+package com.chameleonvision.util;
+
+import java.lang.Math;
+
+import edu.wpi.first.wpiutil.math.Num;
+import org.apache.commons.math3.util.FastMath;
+
+public class MathHandler {
+    MathHandler() {}
+
+    public static double sigmoid(Number x){
+        double bias = 0;
+        double a = 5;
+        double b = -0.05;
+        double k = 200;
+
+        if (x.doubleValue() < 50){
+            bias = -1.338;
+        }
+
+        return ((k / (1 + Math.pow(Math.E,(a + (b * x.doubleValue()))))) + bias);
+    }
+
+    public static double toSlope(Number angle){
+        return FastMath.atan(FastMath.toRadians(angle.doubleValue() - 90));
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/util/MemoryManager.java

@@ -0,0 +1,46 @@
+package com.chameleonvision.util;
+
+public class MemoryManager {
+
+	private static final long MEGABYTE_FACTOR = 1024L * 1024L;
+
+	private int collectionThreshold;
+	private int lastUsedMb = 0;
+
+	public MemoryManager(int collectionThreshold) {
+		this.collectionThreshold = collectionThreshold;
+	}
+
+	public void setCollectionThreshold(int collectionThreshold) {
+		this.collectionThreshold = collectionThreshold;
+	}
+
+	public static long getUsedMemory() {
+		return Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
+	}
+
+	public static int getUsedMemoryMB() {
+		return (int) (getUsedMemory() / MEGABYTE_FACTOR);
+	}
+
+	private static void collect() {
+		System.gc();
+		System.runFinalization();
+	}
+
+	public void run() { run(false); }
+
+	public void run(boolean print) {
+		var usedMem = getUsedMemoryMB();
+
+		if (usedMem != lastUsedMb) {
+			lastUsedMb = usedMem;
+			if (print) System.out.printf("Memory usage: %dMB\n", usedMem);
+		}
+
+		if (usedMem >= collectionThreshold) {
+			collect();
+			if (print) System.out.printf("Garbage collected at %dMB\n", usedMem);
+		}
+	}
+}

chameleon-server/src/main/java/com/chameleonvision/util/Platform.java

@@ -0,0 +1,98 @@
+package com.chameleonvision.util;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+public enum Platform {
+	WINDOWS_64("Windows x64"),
+	LINUX_64("Linux x64"),
+	LINUX_RASPBIAN("Linux Raspbian"),
+	LINUX_ARM64("Linux ARM64"),
+	MACOS_64("Mac OS x64"),
+	UNSUPPORTED("Unsupported Platform");
+
+	public final String value;
+
+	Platform(String value) {
+		this.value = value;
+	}
+
+	private static final String OS_NAME =  System.getProperty("os.name");
+	private static final String OS_ARCH = System.getProperty("os.arch");
+	public static final Platform CurrentPlatform = getCurrentPlatform();
+
+	public boolean isWindows() {
+		return this == WINDOWS_64;
+	}
+
+	public boolean isLinux() {
+		return this == LINUX_64 || this == LINUX_RASPBIAN || this == LINUX_ARM64;
+	}
+
+	public boolean isMac() {
+		return this == MACOS_64;
+	}
+
+	private static ShellExec shell = new ShellExec(true, false);
+
+	public boolean isRoot() {
+		if (isLinux() || isMac()) {
+			try {
+				shell.execute("id", null, true, "-u");
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			while (!shell.isOutputCompleted()) {
+				// ignored
+			}
+			if (shell.getExitCode() == 0) {
+				var out = shell.getOutput();
+				out = out.split("\n")[0];
+				return out.equals("0");
+			}
+		} else if (isWindows()) {
+			return true;
+		} else {
+			return true;
+		}
+		return false;
+	}
+
+	private static boolean isRaspbian() {
+		try (BufferedReader reader = Files.newBufferedReader(Paths.get("/etc/os-release"))) {
+			String value = reader.readLine();
+			return value.contains("Raspbian");
+		} catch (IOException ex) {
+			return false;
+		}
+	}
+
+	public static Platform getCurrentPlatform() {
+		if (OS_NAME.contains("Windows")) {
+			if (OS_ARCH.equals("amd64")) return Platform.WINDOWS_64;
+		}
+
+		if (OS_NAME.contains("Linux")) {
+			if (OS_ARCH.equals("amd64")) return Platform.LINUX_64;
+			if (isRaspbian()) return Platform.LINUX_RASPBIAN;
+			if (OS_ARCH.contains("aarch")) return Platform.LINUX_ARM64;
+		}
+
+		if (OS_NAME.contains("Mac")) {
+			if (OS_ARCH.equals("amd64")) return Platform.MACOS_64;
+		}
+
+		System.out.printf("Unknown Platform! OS: %s, Architecture: %s", OS_NAME, OS_ARCH);
+		return Platform.UNSUPPORTED;
+	}
+
+	public String toString() {
+		if (this.equals(UNSUPPORTED)) {
+			return String.format("Unknown Platform. OS: %s, Architecture: %s", OS_NAME, OS_ARCH);
+		} else {
+			return this.value;
+		}
+	}
+}

chameleon-server/src/main/java/com/chameleonvision/util/ProgramDirectoryUtilities.java

@@ -0,0 +1,52 @@
+package com.chameleonvision.util;
+
+import java.io.File;
+import java.net.URISyntaxException;
+
+public class ProgramDirectoryUtilities
+{
+    private static String getJarName()
+    {
+        return new File(ProgramDirectoryUtilities.class.getProtectionDomain()
+                .getCodeSource()
+                .getLocation()
+                .getPath())
+                .getName();
+    }
+
+    private static boolean runningFromJAR()
+    {
+        String jarName = getJarName();
+        return jarName.contains(".jar");
+    }
+
+    public static String getProgramDirectory()
+    {
+        if (runningFromJAR())
+        {
+            return getCurrentJARDirectory();
+        } else
+        {
+            return System.getProperty("user.dir");
+//            return getCurrentProjectDirectory();
+        }
+    }
+
+    private static String getCurrentProjectDirectory()
+    {
+        return new File("").getAbsolutePath();
+    }
+
+    private static String getCurrentJARDirectory()
+    {
+        try
+        {
+            return new File(ProgramDirectoryUtilities.class.getProtectionDomain().getCodeSource().getLocation().toURI().getPath()).getParent();
+        } catch (URISyntaxException exception)
+        {
+            exception.printStackTrace();
+        }
+
+        return null;
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/util/ShellExec.java

@@ -0,0 +1,151 @@
+package com.chameleonvision.util;
+
+import java.io.*;
+
+/**
+ * Execute external process and optionally read output buffer.
+ */
+public class ShellExec {
+    private int exitCode;
+    private boolean readOutput, readError;
+    private StreamGobbler errorGobbler, outputGobbler;
+
+    public ShellExec() {
+        this(false, false);
+    }
+
+    public ShellExec(boolean readOutput, boolean readError) {
+        this.readOutput = readOutput;
+        this.readError = readError;
+    }
+
+    /**
+     * Execute a command in current folder, and wait for process to end
+     * @param command   command ("c:/some/folder/script.bat" or "some/folder/script.sh")
+     * @param args  0..n command line arguments
+     * @return  process exit code
+     */
+    public int execute(String command, String... args) throws IOException {
+        return execute(command, null, true, args);
+    }
+
+    /**
+     * Execute a command.
+     * @param command   command ("c:/some/folder/script.bat" or "some/folder/script.sh")
+     * @param workdir   working directory or NULL to use command folder
+     * @param wait  wait for process to end
+     * @param args  0..n command line arguments
+     * @return  process exit code
+     */
+    public int execute(String command, String workdir, boolean wait, String...args) throws IOException {
+        String[] cmdArr;
+        if (args != null && args.length > 0) {
+            cmdArr = new String[1+args.length];
+            cmdArr[0] = command;
+            System.arraycopy(args, 0, cmdArr, 1, args.length);
+        } else {
+            cmdArr = new String[] { command };
+        }
+
+        ProcessBuilder pb =  new ProcessBuilder(cmdArr);
+        File workingDir = (workdir==null ? new File(command).getParentFile() : new File(workdir) );
+        pb.directory(workingDir);
+
+        Process process = pb.start();
+
+        // Consume streams, older jvm's had a memory leak if streams were not read,
+        // some other jvm+OS combinations may block unless streams are consumed.
+        errorGobbler  = new StreamGobbler(process.getErrorStream(), readError);
+        outputGobbler = new StreamGobbler(process.getInputStream(), readOutput);
+        errorGobbler.start();
+        outputGobbler.start();
+
+        exitCode = 0;
+        if (wait) {
+            try {
+                process.waitFor();
+                exitCode = process.exitValue();
+            } catch (InterruptedException ignored) { }
+        }
+        return exitCode;
+    }
+
+    public int getExitCode() {
+        return exitCode;
+    }
+
+    public boolean isOutputCompleted() {
+        return (outputGobbler != null && outputGobbler.isCompleted());
+    }
+
+    public boolean isErrorCompleted() {
+        return (errorGobbler != null && errorGobbler.isCompleted());
+    }
+
+    public String getOutput() {
+        return (outputGobbler != null ? outputGobbler.getOutput() : null);
+    }
+
+    public String getError() {
+        return (errorGobbler != null ? errorGobbler.getOutput() : null);
+    }
+
+//********************************************
+//********************************************
+
+    /**
+     * StreamGobbler reads inputstream to "gobble" it.
+     * This is used by Executor class when running
+     * a commandline applications. Gobblers must read/purge
+     * INSTR and ERRSTR process streams.
+     * http://www.javaworld.com/javaworld/jw-12-2000/jw-1229-traps.html?page=4
+     */
+    @SuppressWarnings("WeakerAccess")
+    private static class StreamGobbler extends Thread {
+        private InputStream is;
+        private StringBuilder output;
+        private volatile boolean completed; // mark volatile to guarantee a thread safety
+
+        public StreamGobbler(InputStream is, boolean readStream) {
+            this.is = is;
+            this.output = (readStream ? new StringBuilder(256) : null);
+        }
+
+        public void run() {
+            completed = false;
+            try {
+                String NL = System.getProperty("line.separator", "\r\n");
+
+                InputStreamReader isr = new InputStreamReader(is);
+                BufferedReader br = new BufferedReader(isr);
+                String line;
+                while ( (line = br.readLine()) != null) {
+                    if (output != null)
+                        output.append(line).append(NL);
+                }
+            } catch (IOException ex) {
+                // ex.printStackTrace();
+            }
+            completed = true;
+        }
+
+        /**
+         * Get inputstream buffer or null if stream
+         * was not consumed.
+         * @return
+         */
+        public String getOutput() {
+            return (output != null ? output.toString() : null);
+        }
+
+        /**
+         * Is input stream completed.
+         * @return
+         */
+        public boolean isCompleted() {
+            return completed;
+        }
+
+    }
+
+}

chameleon-server/src/main/java/com/chameleonvision/util/Utilities.java

@@ -0,0 +1,40 @@
+package com.chameleonvision.util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Utilities {
+    private Utilities() {}
+
+    public static boolean isValidIPV4(final String ip) {
+        String PATTERN = "^((0|1\\d?\\d?|2[0-4]?\\d?|25[0-5]?|[3-9]\\d?)\\.){3}(0|1\\d?\\d?|2[0-4]?\\d?|25[0-5]?|[3-9]\\d?)$";
+
+        return ip.matches(PATTERN);
+    }
+
+    public static List<Byte> getDigitBytes(int num) {
+        List<Byte> digits = new ArrayList<>();
+        collectDigitBytes(num, digits);
+        return digits;
+    }
+
+    private static void collectDigitBytes(int num, List<Byte> digits) {
+        if (num / 10 > 0) {
+            collectDigitBytes( num / 10, digits);
+        }
+        digits.add((byte) (num % 10));
+    }
+
+    public static List<Integer> getDigits(int num) {
+        List<Integer> digits = new ArrayList<>();
+        collectDigits(num, digits);
+        return digits;
+    }
+
+    private static void collectDigits(int num, List<Integer> digits) {
+        if(num / 10 > 0) {
+            collectDigits(num / 10, digits);
+        }
+        digits.add(num % 10);
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/VisionManager.java

@@ -0,0 +1,180 @@
+package com.chameleonvision.vision;
+
+import com.chameleonvision.config.CameraConfig;
+import com.chameleonvision.config.CameraJsonConfig;
+import com.chameleonvision.config.ConfigManager;
+import com.chameleonvision.config.FullCameraConfiguration;
+import com.chameleonvision.util.Helpers;
+import com.chameleonvision.util.Platform;
+import com.chameleonvision.vision.camera.CameraCapture;
+import com.chameleonvision.vision.camera.USBCameraCapture;
+import com.chameleonvision.vision.pipeline.CVPipelineSettings;
+import edu.wpi.cscore.UsbCamera;
+import edu.wpi.cscore.UsbCameraInfo;
+import org.opencv.videoio.VideoCapture;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class VisionManager {
+    private VisionManager() {
+    }
+
+    private static final LinkedHashMap<String, UsbCameraInfo> usbCameraInfosByCameraName = new LinkedHashMap<>();
+    private static final LinkedList<FullCameraConfiguration> loadedCameraConfigs = new LinkedList<>();
+    private static final LinkedList<VisionProcessManageable> visionProcesses = new LinkedList<>();
+
+    @SuppressWarnings("WeakerAccess")
+    private static class VisionProcessManageable {
+        public final int index;
+        public final String name;
+        public final VisionProcess visionProcess;
+
+        public VisionProcessManageable(int index, String name, VisionProcess visionProcess) {
+            this.index = index;
+            this.name = name;
+            this.visionProcess = visionProcess;
+        }
+    }
+
+    private static VisionProcess currentUIVisionProcess;
+
+    public static boolean initializeSources() {
+        int suffix = 0;
+        for (UsbCameraInfo info : UsbCamera.enumerateUsbCameras()) {
+            VideoCapture cap = new VideoCapture(info.dev);
+            if (cap.isOpened()) {
+                cap.release();
+                String name = info.name;
+                while (usbCameraInfosByCameraName.containsKey(name)) {
+                    suffix++;
+                    name = String.format("%s (%d)", name, suffix);
+                }
+                usbCameraInfosByCameraName.put(name, info);
+            }
+        }
+
+        if (usbCameraInfosByCameraName.isEmpty()) {
+            return false;
+        }
+
+        // load the config
+        List<CameraJsonConfig> preliminaryConfigs = new ArrayList<>();
+
+        usbCameraInfosByCameraName.values().forEach((cameraInfo) -> {
+            String truePath;
+
+            if (Platform.CurrentPlatform.isWindows()) {
+                truePath = cameraInfo.path;
+            } else {
+                truePath = Arrays.stream(cameraInfo.otherPaths).filter(x -> x.contains("/dev/v4l/by-path")).findFirst().orElse(cameraInfo.path);
+            }
+
+            preliminaryConfigs.add(new CameraJsonConfig(truePath, cameraInfo.name));
+        });
+
+        loadedCameraConfigs.addAll(ConfigManager.initializeCameras(preliminaryConfigs));
+
+        return true;
+    }
+
+    public static boolean initializeProcesses() {
+        for (int i = 0; i < loadedCameraConfigs.size(); i++) {
+            FullCameraConfiguration config = loadedCameraConfigs.get(i);
+
+            CameraJsonConfig cameraJsonConfig = config.cameraConfig;
+
+            CameraCapture camera = new USBCameraCapture(cameraJsonConfig);
+            VisionProcess process = new VisionProcess(camera, cameraJsonConfig.name, config.pipelines);
+            process.pipelineManager.driverModePipeline.settings = config.drivermode;
+            visionProcesses.add(new VisionProcessManageable(i, cameraJsonConfig.name, process));
+        }
+        currentUIVisionProcess = getVisionProcessByIndex(0);
+        ConfigManager.settings.currentCamera = visionProcesses.get(0).name;
+        return true;
+    }
+
+    public static void startProcesses() {
+        visionProcesses.forEach((vpm) -> vpm.visionProcess.start());
+    }
+
+    public static VisionProcess getCurrentUIVisionProcess() {
+        return currentUIVisionProcess;
+    }
+
+    public static CameraConfig getCameraConfig(VisionProcess process) {
+        String cameraName = process.getCamera().getProperties().name;
+        return Objects.requireNonNull(loadedCameraConfigs.stream().filter(x -> x.cameraConfig.name.equals(cameraName)).findFirst().orElse(null)).fileConfig;
+    }
+
+    public static void setCurrentProcessByIndex(int processIndex) {
+        if (processIndex > visionProcesses.size() - 1) {
+            return;
+        }
+
+        currentUIVisionProcess = getVisionProcessByIndex(processIndex);
+        ConfigManager.settings.currentCamera = visionProcesses.get(processIndex).name;
+    }
+
+    public static VisionProcess getVisionProcessByIndex(int processIndex) {
+        if (processIndex > visionProcesses.size() - 1) {
+            return null;
+        }
+
+        VisionProcessManageable vpm =  visionProcesses.stream().filter(manageable -> manageable.index == processIndex).findFirst().orElse(null);
+        return vpm != null ? vpm.visionProcess : null;
+    }
+
+    public static List<String> getAllCameraNicknames() {
+        return visionProcesses.stream().map(vpm -> vpm.visionProcess.getCamera()
+                .getProperties().getNickname()).collect(Collectors.toList());
+    }
+
+    public static List<String> getCurrentCameraPipelineNicknames() {
+        return currentUIVisionProcess.pipelineManager.pipelines.stream().map(cvPipeline -> cvPipeline.settings.nickname).collect(Collectors.toList());
+    }
+
+
+    public static void saveAllCameras() {
+        visionProcesses.forEach((vpm) -> {
+            VisionProcess process = vpm.visionProcess;
+            String cameraName = process.getCamera().getProperties().name;
+            List<CVPipelineSettings> pipelines = process.pipelineManager.pipelines.stream().map(cvPipeline -> cvPipeline.settings).collect(Collectors.toList());
+            CVPipelineSettings driverMode = process.getDriverModeSettings();
+            CameraJsonConfig config = CameraJsonConfig.fromVisionProcess(process);
+            ConfigManager.saveCameraPipelines(cameraName, pipelines);
+            ConfigManager.saveCameraDriverMode(cameraName, driverMode);
+            ConfigManager.saveCameraConfig(cameraName, config);
+        });
+    }
+
+    private static String getCurrentCameraName() {
+        return currentUIVisionProcess.getCamera().getProperties().name;
+    }
+
+    public static void saveCurrentCameraSettings() {
+        CameraJsonConfig config = CameraJsonConfig.fromVisionProcess(currentUIVisionProcess);
+        ConfigManager.saveCameraConfig(getCurrentCameraName(), config);
+    }
+
+    public static void saveCurrentCameraPipelines() {
+        currentUIVisionProcess.pipelineManager.saveAllPipelines();
+    }
+
+    public static void saveCurrentCameraDriverMode() {
+        currentUIVisionProcess.pipelineManager.saveDriverModeConfig();
+    }
+
+    private static List<HashMap> getCameraResolutionList(CameraCapture capture) {
+        return capture.getProperties().getVideoModes().stream().map(Helpers::VideoModeToHashMap).collect(Collectors.toList());
+    }
+
+    public static List<HashMap> getCurrentCameraResolutionList() {
+        return getCameraResolutionList(currentUIVisionProcess.getCamera());
+    }
+
+    public static int getCurrentUIVisionProcessIndex() {
+        VisionProcessManageable vpm = visionProcesses.stream().filter(v -> v.visionProcess == currentUIVisionProcess).findFirst().orElse(null);
+        return vpm != null ? vpm.index : -1;
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/VisionProcess.java

@@ -0,0 +1,303 @@
+package com.chameleonvision.vision;
+
+import com.chameleonvision.Debug;
+import com.chameleonvision.config.ConfigManager;
+import com.chameleonvision.util.LoopingRunnable;
+import com.chameleonvision.vision.camera.CameraCapture;
+import com.chameleonvision.vision.camera.CameraStreamer;
+import com.chameleonvision.vision.pipeline.*;
+import com.chameleonvision.web.SocketHandler;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import edu.wpi.cscore.VideoMode;
+import edu.wpi.first.networktables.*;
+import edu.wpi.first.wpiutil.CircularBuffer;
+import org.apache.commons.lang3.tuple.Pair;
+import org.opencv.core.Mat;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingDeque;
+
+
+public class VisionProcess {
+
+    private final CameraCapture cameraCapture;
+    private final CameraStreamerRunnable streamRunnable;
+    private final VisionProcessRunnable visionRunnable;
+    public final CameraStreamer cameraStreamer;
+    public PipelineManager pipelineManager;
+
+    private volatile CVPipelineResult lastPipelineResult;
+
+    private BlockingQueue<Mat> streamFrameQueue = new LinkedBlockingDeque<>(1);
+
+    // network table stuff
+    private final NetworkTable defaultTable;
+    private NetworkTableEntry ntPipelineEntry;
+    public NetworkTableEntry ntDriverModeEntry;
+    private int ntDriveModeListenerID;
+    private int ntPipelineListenerID;
+    private NetworkTableEntry ntYawEntry;
+    private NetworkTableEntry ntPitchEntry;
+    private NetworkTableEntry ntAuxListEntry;
+    private NetworkTableEntry ntAreaEntry;
+    private NetworkTableEntry ntTimeStampEntry;
+    private NetworkTableEntry ntValidEntry;
+    private ObjectMapper objectMapper = new ObjectMapper();
+
+    VisionProcess(CameraCapture cameraCapture, String name, List<CVPipelineSettings> loadedPipelineSettings) {
+        this.cameraCapture = cameraCapture;
+
+        pipelineManager = new PipelineManager(this, loadedPipelineSettings);
+
+        // Thread to put frames on the dashboard
+        this.cameraStreamer = new CameraStreamer(cameraCapture, name);
+        this.streamRunnable = new CameraStreamerRunnable(30, cameraStreamer);
+
+        // Thread to process vision data
+        this.visionRunnable = new VisionProcessRunnable();
+
+        // network table
+        defaultTable = NetworkTableInstance.getDefault().getTable("/chameleon-vision/" + cameraCapture.getProperties().getNickname());
+    }
+
+    public void start() {
+        System.out.println("Starting NetworkTables.");
+        initNT(defaultTable);
+
+        System.out.println("Starting vision thread.");
+        var visionThread = new Thread(visionRunnable);
+        visionThread.setName(getCamera().getProperties().name + " - Vision Thread");
+        visionThread.start();
+
+        System.out.println("Starting stream thread.");
+        var streamThread = new Thread(streamRunnable);
+        streamThread.setName(getCamera().getProperties().name + " - Stream Thread");
+        streamThread.start();
+    }
+
+    /**
+     * Removes the old value change listeners
+     * calls {@link #initNT}
+     *
+     * @param newTable passed to {@link #initNT}
+     */
+    public void resetNT(NetworkTable newTable) {
+        ntDriverModeEntry.removeListener(ntDriveModeListenerID);
+        ntPipelineEntry.removeListener(ntPipelineListenerID);
+        initNT(newTable);
+    }
+
+    public void setCameraNickname(String newName) {
+        getCamera().getProperties().setNickname(newName);
+        var newTable = NetworkTableInstance.getDefault().getTable("/chameleon-vision/" + newName);
+        resetNT(newTable);
+    }
+
+    private void initNT(NetworkTable newTable) {
+        ntPipelineEntry = newTable.getEntry("pipeline");
+        ntDriverModeEntry = newTable.getEntry("driver_mode");
+        ntPitchEntry = newTable.getEntry("pitch");
+        ntYawEntry = newTable.getEntry("yaw");
+        ntAreaEntry = newTable.getEntry("area");
+        ntTimeStampEntry = newTable.getEntry("timestamp");
+        ntValidEntry = newTable.getEntry("is_valid");
+        ntAuxListEntry = newTable.getEntry("aux_targets");
+        ntDriveModeListenerID = ntDriverModeEntry.addListener(this::setDriverMode, EntryListenerFlags.kUpdate);
+        ntPipelineListenerID = ntPipelineEntry.addListener(this::setPipeline, EntryListenerFlags.kUpdate);
+        ntDriverModeEntry.setBoolean(false);
+        ntPipelineEntry.setNumber(pipelineManager.getCurrentPipelineIndex());
+        pipelineManager.ntIndexEntry = ntPipelineEntry;
+    }
+
+    private void setDriverMode(EntryNotification driverModeEntryNotification) {
+        setDriverMode(driverModeEntryNotification.value.getBoolean());
+    }
+
+    public void setDriverMode(boolean driverMode) {
+        pipelineManager.setDriverMode(driverMode);
+        SocketHandler.sendFullSettings();
+    }
+
+    /**
+     * Method called by the nt entry listener to update the next pipeline.
+     * @param notification the notification
+     */
+    private void setPipeline(EntryNotification notification) {
+        var wantedPipelineIndex = (int) notification.value.getDouble();
+        pipelineManager.setCurrentPipeline(wantedPipelineIndex);
+    }
+
+    public void setDriverModeEntry(boolean isDriverMode) {
+
+        // if it's null, we haven't even started the program yet, so just return
+        // otherwise, set it.
+        if(ntDriverModeEntry != null) {
+            ntDriverModeEntry.setBoolean(isDriverMode);
+        }
+    }
+
+    private void updateUI(CVPipelineResult data) {
+        if(cameraCapture.getProperties().name.equals(ConfigManager.settings.currentCamera)) {
+            HashMap<String, Object> WebSend = new HashMap<>();
+            HashMap<String, Object> point = new HashMap<>();
+            HashMap<String, Object> calculated = new HashMap<>();
+            List<Double> center = new ArrayList<>();
+            if (data.hasTarget) {
+                if(data instanceof CVPipeline2d.CVPipeline2dResult) {
+                    CVPipeline2d.CVPipeline2dResult result = (CVPipeline2d.CVPipeline2dResult) data;
+                    CVPipeline2d.Target2d bestTarget = result.targets.get(0);
+                    center.add(bestTarget.rawPoint.center.x);
+                    center.add(bestTarget.rawPoint.center.y);
+                    calculated.put("pitch", bestTarget.pitch);
+                    calculated.put("yaw", bestTarget.yaw);
+                    calculated.put("area", bestTarget.area);
+                } else if (data instanceof CVPipeline3d.CVPipeline3dResult) {
+                    // TODO: (2.1) 3d stuff in UI
+                } else {
+                    center.add(0.0);
+                    center.add(0.0);
+                    calculated.put("pitch", 0);
+                    calculated.put("yaw", 0);
+                }
+            } else {
+                center.add(0.0);
+                center.add(0.0);
+                calculated.put("pitch", 0);
+                calculated.put("yaw", 0);
+            }
+            point.put("fps", visionRunnable.fps);
+            point.put("calculated", calculated);
+            point.put("rawPoint", center);
+            WebSend.put("point", point);
+            SocketHandler.broadcastMessage(WebSend);
+        }
+    }
+
+    private void updateNetworkTableData(CVPipelineResult data) {
+        ntValidEntry.setBoolean(data.hasTarget);
+        if(data.hasTarget && !(data instanceof DriverVisionPipeline.DriverPipelineResult)) {
+            if(data instanceof CVPipeline2d.CVPipeline2dResult) {
+
+                //noinspection unchecked
+                List<CVPipeline2d.Target2d> targets = (List<CVPipeline2d.Target2d>) data.targets;
+                ntTimeStampEntry.setDouble(data.imageTimestamp);
+                ntPitchEntry.setDouble(targets.get(0).pitch);
+                ntYawEntry.setDouble(targets.get(0).yaw);
+                ntAreaEntry.setDouble(targets.get(0).area);
+                try {
+                    ntAuxListEntry.setString(objectMapper.writeValueAsString(targets));
+                } catch (JsonProcessingException e) {
+                    e.printStackTrace();
+                }
+            } else if (data instanceof CVPipeline3d.CVPipeline3dResult) {
+                // TODO: (2.1) 3d stuff...
+            }
+        } else {
+            ntPitchEntry.setDouble(0.0);
+            ntYawEntry.setDouble(0.0);
+            ntAreaEntry.setDouble(0.0);
+            ntTimeStampEntry.setDouble(0.0);
+            ntAuxListEntry.setString("");
+        }
+    }
+
+    public void setVideoMode(VideoMode newMode) {
+        cameraCapture.setVideoMode(newMode);
+        cameraStreamer.setNewVideoMode(newMode);
+    }
+
+    public VideoMode getCurrentVideoMode() {
+        return cameraCapture.getCurrentVideoMode();
+    }
+
+    public List<VideoMode> getPossibleVideoModes() {
+        return cameraCapture.getProperties().videoModes;
+    }
+
+    public CameraCapture getCamera() {
+        return cameraCapture;
+    }
+
+    public CVPipelineSettings getDriverModeSettings() {
+        return pipelineManager.driverModePipeline.settings;
+    }
+
+    /**
+     * VisionProcessRunnable will process images as quickly as possible
+     */
+    private class VisionProcessRunnable implements Runnable {
+
+        volatile Double fps = 0.0;
+        private CircularBuffer fpsAveragingBuffer = new CircularBuffer(7);
+
+        @Override
+        public void run() {
+            var lastUpdateTimeNanos = System.nanoTime();
+            while(!Thread.interrupted()) {
+
+                // blocking call, will block until camera has a new frame.
+                Pair<Mat, Long> camData = cameraCapture.getFrame();
+
+                Mat camFrame = camData.getLeft();
+                if (camFrame.cols() > 0 && camFrame.rows() > 0) {
+                    CVPipelineResult result = pipelineManager.getCurrentPipeline().runPipeline(camFrame);
+
+                    if (result != null) {
+                        result.setTimestamp(camData.getRight());
+                        lastPipelineResult = result;
+                        updateNetworkTableData(lastPipelineResult);
+                        updateUI(lastPipelineResult);
+                    }
+                }
+
+                try {
+                    streamFrameQueue.clear();
+                    streamFrameQueue.add(lastPipelineResult.outputMat);
+                } catch (Exception e) {
+                    Debug.printInfo("Vision running faster than stream.");
+                }
+
+                var deltaTimeNanos = System.nanoTime() - lastUpdateTimeNanos;
+                fpsAveragingBuffer.addFirst(1.0 / (deltaTimeNanos * 1E-09));
+                lastUpdateTimeNanos = System.nanoTime();
+                fps = getAverageFPS();
+            }
+        }
+
+        double getAverageFPS() {
+            var temp = 0.0;
+            for(int i = 0; i < 7; i++) {
+                temp += fpsAveragingBuffer.get(i);
+            }
+            temp /= 7.0;
+            return temp;
+        }
+
+    }
+
+    private class CameraStreamerRunnable extends LoopingRunnable {
+
+        final CameraStreamer streamer;
+
+        private CameraStreamerRunnable(int cameraFPS, CameraStreamer streamer) {
+            // add 2 FPS to allow for a bit of overhead
+            super(1000L/(cameraFPS + 2));
+            this.streamer = streamer;
+        }
+
+        @Override
+        protected void process() {
+            if (!streamFrameQueue.isEmpty()) {
+                try {
+                    streamer.runStream(streamFrameQueue.take());
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/camera/CameraCapture.java

@@ -0,0 +1,41 @@
+package com.chameleonvision.vision.camera;
+
+import com.chameleonvision.vision.image.ImageCapture;
+import edu.wpi.cscore.VideoMode;
+
+public interface CameraCapture extends ImageCapture {
+    USBCameraProperties getProperties();
+
+    VideoMode getCurrentVideoMode();
+
+    /**
+     * Set the exposure of the camera
+     * @param exposure the new exposure to set the camera to
+     */
+    void setExposure(int exposure);
+
+    /**
+     * Set the brightness of the camera
+     * @param brightness the new brightness to set the camera to
+     */
+    void setBrightness(int brightness);
+
+    /**
+     * Set the video mode (fps and resolution) of the camera
+     * @param mode the desired mode
+     */
+    void setVideoMode(VideoMode mode);
+
+    /**
+     * Set the video mode (fps and resolution) of the camera
+     * @param index the index of the desired mode
+     */
+    void setVideoMode(int index);
+
+    /**
+     * Set the gain of the camera
+     * NOTE - Not all cameras support this.
+     * @param gain the new gain to set the camera to
+     */
+    void setGain(int gain);
+}

chameleon-server/src/main/java/com/chameleonvision/vision/camera/CameraStreamer.java

@@ -0,0 +1,85 @@
+package com.chameleonvision.vision.camera;
+
+import com.chameleonvision.vision.enums.StreamDivisor;
+import com.chameleonvision.web.SocketHandler;
+import edu.wpi.cscore.CvSource;
+import edu.wpi.cscore.MjpegServer;
+import edu.wpi.cscore.VideoMode;
+import edu.wpi.first.cameraserver.CameraServer;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Size;
+import org.opencv.imgproc.Imgproc;
+
+public class CameraStreamer {
+    private final CameraCapture cameraCapture;
+    private final String name;
+    private StreamDivisor divisor = StreamDivisor.NONE;
+    private CvSource cvSource;
+    private final Object streamBufferLock = new Object();
+    private Mat streamBuffer = new Mat();
+    private Size size;
+
+    public CameraStreamer(CameraCapture cameraCapture, String name) {
+        this.cameraCapture = cameraCapture;
+        this.name = name;
+        this.cvSource = CameraServer.getInstance().putVideo(name,
+                cameraCapture.getProperties().getStaticProperties().imageWidth / divisor.value,
+                cameraCapture.getProperties().getStaticProperties().imageHeight / divisor.value);
+        //noinspection IntegerDivisionInFloatingPointContext
+        this.size = new Size(
+                cameraCapture.getProperties().getStaticProperties().imageWidth / divisor.value,
+                cameraCapture.getProperties().getStaticProperties().imageHeight / divisor.value
+        );
+        setDivisor(divisor, false);
+    }
+
+    public void setDivisor(StreamDivisor newDivisor, boolean updateUI) {
+        if (divisor != newDivisor) {
+            this.divisor = newDivisor;
+            var camValues = cameraCapture.getProperties();
+            var newWidth = camValues.getStaticProperties().imageWidth / newDivisor.value;
+            var newHeight = camValues.getStaticProperties().imageHeight / newDivisor.value;
+            this.size = new Size(newWidth, newHeight);
+            synchronized (streamBufferLock) {
+                this.streamBuffer = new Mat(newWidth, newHeight, CvType.CV_8UC3);
+                this.cvSource = CameraServer.getInstance().putVideo(this.name,
+                        cameraCapture.getProperties().getStaticProperties().imageWidth / divisor.value,
+                        cameraCapture.getProperties().getStaticProperties().imageHeight / divisor.value);
+            }
+            if (updateUI) {
+                SocketHandler.sendFullSettings();
+            }
+        }
+    }
+
+    public StreamDivisor getDivisor() {
+        return divisor;
+    }
+
+    public void setNewVideoMode(VideoMode newVideoMode) {
+        // Trick to update cvSource and streamBuffer to the new resolution
+        // Must change the cameraProcess resolution first
+        setDivisor(divisor, true);
+    }
+
+    public int getStreamPort() {
+        var s = (MjpegServer) CameraServer.getInstance().getServer("serve_" + name);
+        return s.getPort();
+    }
+
+    public void runStream(Mat image) {
+        synchronized (streamBufferLock) {
+            image.copyTo(streamBuffer);
+        }
+
+        if (divisor.value != 1) {
+//            var camVal = cameraProcess.getProperties().staticProperties;
+//            var newWidth = camVal.imageWidth / divisor.value;
+//            var newHeight = camVal.imageHeight / divisor.value;
+//            Size newSize = new Size(newWidth, newHeight);
+             Imgproc.resize(streamBuffer, streamBuffer, this.size);
+        }
+        cvSource.putFrame(streamBuffer);
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/camera/CaptureStaticProperties.java

@@ -0,0 +1,39 @@
+package com.chameleonvision.vision.camera;
+
+import edu.wpi.cscore.VideoMode;
+import org.apache.commons.math3.fraction.Fraction;
+import org.apache.commons.math3.util.FastMath;
+
+public class CaptureStaticProperties {
+
+    public final int imageWidth;
+    public final int imageHeight;
+    public final double fov;
+    public final double imageArea;
+    public final double centerX;
+    public final double centerY;
+    public final double horizontalFocalLength;
+    public final double verticalFocalLength;
+    public final VideoMode mode;
+
+    public CaptureStaticProperties(VideoMode mode, int imageWidth, int imageHeight, double fov) {
+        this.mode = mode;
+        this.imageWidth = imageWidth;
+        this.imageHeight = imageHeight;
+        this.fov = fov;
+        imageArea = this.imageWidth * this.imageHeight;
+        centerX = ((double) this.imageWidth / 2) - 0.5;
+        centerY = ((double) this.imageHeight / 2) - 0.5;
+
+        // pinhole model calculations
+        double diagonalView = FastMath.toRadians(this.fov);
+        Fraction aspectFraction = new Fraction(this.imageWidth, this.imageHeight);
+        int horizontalRatio = aspectFraction.getNumerator();
+        int verticalRatio = aspectFraction.getDenominator();
+        double diagonalAspect = FastMath.hypot(horizontalRatio, verticalRatio);
+        double horizontalView = FastMath.atan(FastMath.tan(diagonalView / 2) * (horizontalRatio / diagonalAspect)) * 2;
+        double verticalView = FastMath.atan(FastMath.tan(diagonalView / 2) * (verticalRatio / diagonalAspect)) * 2;
+        horizontalFocalLength = this.imageWidth / (2 * FastMath.tan(horizontalView /2));
+        verticalFocalLength = this.imageHeight / (2 * FastMath.tan(verticalView /2));
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/camera/USBCameraCapture.java

@@ -0,0 +1,89 @@
+package com.chameleonvision.vision.camera;
+
+import com.chameleonvision.config.CameraJsonConfig;
+import edu.wpi.cscore.CvSink;
+import edu.wpi.cscore.UsbCamera;
+import edu.wpi.cscore.VideoException;
+import edu.wpi.cscore.VideoMode;
+import edu.wpi.first.cameraserver.CameraServer;
+import org.apache.commons.lang3.tuple.Pair;
+import org.opencv.core.Mat;
+
+public class USBCameraCapture implements CameraCapture {
+    private final UsbCamera baseCamera;
+    private final CvSink cvSink;
+    private Mat imageBuffer = new Mat();
+    private USBCameraProperties properties;
+
+    public USBCameraCapture(CameraJsonConfig config) {
+        baseCamera = new UsbCamera(config.name, config.path);
+        cvSink = CameraServer.getInstance().getVideo(baseCamera);
+        properties = new USBCameraProperties(baseCamera, config);
+
+        int videoMode = properties.videoModes.size() - 1 <= config.videomode ? config.videomode : 0;
+        setVideoMode(videoMode);
+    }
+
+    @Override
+    public USBCameraProperties getProperties() {
+        return properties;
+    }
+
+    @Override
+    public VideoMode getCurrentVideoMode() {
+        return baseCamera.getVideoMode();
+    }
+
+    @Override
+    public Pair<Mat, Long> getFrame() {
+        Long deltaTime;
+        // TODO: Why multiply by 1000 here?
+        deltaTime = cvSink.grabFrame(imageBuffer) * 1000L;
+        return Pair.of(imageBuffer, deltaTime);
+    }
+
+    @Override
+    public void setExposure(int exposure) {
+        try {
+            baseCamera.setExposureManual(exposure);
+        } catch (VideoException e) {
+            System.err.println("Failed to change camera exposure!");
+        }
+    }
+
+    @Override
+    public void setBrightness(int brightness) {
+        try {
+            baseCamera.setBrightness(brightness);
+        } catch (VideoException e) {
+            System.err.println("Failed to change camera brightness!");
+        }
+    }
+
+    @Override
+    public void setVideoMode(VideoMode mode) {
+        try {
+            baseCamera.setVideoMode(mode);
+            properties.updateVideoMode(mode);
+        } catch (VideoException e) {
+            System.err.println("Failed to change camera video mode!");
+        }
+    }
+
+    public void setVideoMode(int index){
+        VideoMode mode = properties.getVideoModes().get(index);
+        setVideoMode(mode);
+    }
+
+    @Override
+    public void setGain(int gain) {
+        if (properties.isPS3Eye) {
+            try {
+                baseCamera.getProperty("gain_automatic").set(0);
+                baseCamera.getProperty("gain").set(gain);
+            } catch (Exception e) {
+                System.err.println("Failed to change camera gain!");
+            }
+        }
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/camera/USBCameraProperties.java

@@ -0,0 +1,109 @@
+package com.chameleonvision.vision.camera;
+
+import com.chameleonvision.config.CameraJsonConfig;
+import com.chameleonvision.util.Platform;
+import com.chameleonvision.vision.image.CaptureProperties;
+import edu.wpi.cscore.UsbCamera;
+import edu.wpi.cscore.VideoMode;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class USBCameraProperties extends CaptureProperties {
+    public static final double DEFAULT_FOV = 70;
+    private static final int DEFAULT_EXPOSURE = 50;
+    private static final int DEFAULT_BRIGHTNESS = 50;
+    private static final int MINIMUM_FPS = 30;
+    private static final int MINIMUM_WIDTH = 320;
+    private static final int MINIMUM_HEIGHT = 200;
+    private static final int MAX_INIT_MS = 1500;
+
+    private static final int PS3EYE_VID = 1415;
+    private static final int PS3EYE_PID = 2000;
+
+    private static final List<VideoMode.PixelFormat> ALLOWED_PIXEL_FORMATS = Arrays.asList(VideoMode.PixelFormat.kYUYV, VideoMode.PixelFormat.kMJPEG);
+
+    private static final Predicate<VideoMode> kMinFPSPredicate = (videoMode -> videoMode.fps >= MINIMUM_FPS);
+    private static final Predicate<VideoMode> kMinSizePredicate = (videoMode -> videoMode.width >= MINIMUM_WIDTH && videoMode.height >= MINIMUM_HEIGHT);
+    private static final Predicate<VideoMode> kPixelFormatPredicate = (videoMode -> ALLOWED_PIXEL_FORMATS.contains(videoMode.pixelFormat));
+
+    public final String name;
+    public final String path;
+    public final List<VideoMode> videoModes;
+
+    private final UsbCamera baseCamera;
+    public final boolean isPS3Eye;
+
+    private String nickname;
+    private double FOV;
+
+    USBCameraProperties(UsbCamera baseCamera, CameraJsonConfig config) {
+        FOV = config.fov;
+        name = config.name;
+        path = config.path;
+        nickname = config.nickname;
+        this.baseCamera = baseCamera;
+
+        int usbVID = baseCamera.getInfo().vendorId;
+        int usbPID = baseCamera.getInfo().productId;
+
+        // wait for camera USB init on Windows, Windows USB is slow...
+        if (Platform.CurrentPlatform == Platform.WINDOWS_64 && !baseCamera.isConnected()) {
+            System.out.print("Waiting on camera... ");
+            long initTimeout = System.nanoTime();
+            while (!baseCamera.isConnected()) {
+                if (((System.nanoTime() - initTimeout) / 1e6) >= MAX_INIT_MS) {
+                    break;
+                }
+            }
+            var initTimeMs = (System.nanoTime() - initTimeout) / 1e6;
+            System.out.printf("USBCameraProcess initialized in %.2fms\n", initTimeMs);
+        }
+
+        isPS3Eye = (usbVID == PS3EYE_VID && usbPID == PS3EYE_PID);
+        videoModes = filterVideoModes(baseCamera.enumerateVideoModes());
+    }
+
+    public void setFOV(double FOV) {
+        if (this.FOV != FOV) {
+            this.FOV = FOV;
+            staticProperties = new CaptureStaticProperties(staticProperties.mode, staticProperties.imageWidth, staticProperties.imageHeight, FOV);
+        }
+    }
+
+    public double getFOV() {
+        return FOV;
+    }
+
+    public void setNickname(String nickname) {
+        this.nickname = nickname;
+    }
+
+    public String getNickname() {
+        return nickname;
+    }
+
+    private List<VideoMode> filterVideoModes(VideoMode[] videoModes) {
+        Predicate<VideoMode> fullPredicate = kMinFPSPredicate.and(kMinSizePredicate).and(kPixelFormatPredicate);
+        Stream<VideoMode> validModes = Arrays.stream(videoModes).filter(fullPredicate);
+        return validModes.collect(Collectors.toList());
+    }
+
+    void updateVideoMode(VideoMode videoMode) {
+        staticProperties = new CaptureStaticProperties(videoMode, videoMode.width, videoMode.height, FOV);
+    }
+
+    public List<VideoMode> getVideoModes() {
+        return videoModes;
+    }
+
+    public VideoMode getCurrentVideoMode() { return staticProperties.mode; }
+
+    public int getCurrentVideoModeIndex(){
+        return getVideoModes().indexOf(getCurrentVideoMode());
+    }
+
+}

chameleon-server/src/main/java/com/chameleonvision/vision/enums/CalibrationMode.java

@@ -0,0 +1,5 @@
+package com.chameleonvision.vision.enums;
+
+public enum CalibrationMode {
+    None,Single,Dual
+}

chameleon-server/src/main/java/com/chameleonvision/vision/enums/ImageFlipMode.java

@@ -0,0 +1,14 @@
+package com.chameleonvision.vision.enums;
+
+public enum ImageFlipMode {
+    NONE(Integer.MIN_VALUE),
+    VERTICAL(1),
+    HORIZONTAL(0),
+    BOTH(-1);
+
+    public final int value;
+
+    ImageFlipMode(int value) {
+        this.value = value;
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/enums/ImageRotationMode.java

@@ -0,0 +1,16 @@
+package com.chameleonvision.vision.enums;
+
+import org.opencv.core.Core;
+
+public enum ImageRotationMode {
+    DEG_0(-1),
+    DEG_90(Core.ROTATE_90_CLOCKWISE),
+    DEG_180(Core.ROTATE_180),
+    DEG_270(Core.ROTATE_90_COUNTERCLOCKWISE);
+
+    public final int value;
+
+    ImageRotationMode(int value) {
+        this.value = value;
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/enums/SortMode.java

@@ -0,0 +1,5 @@
+package com.chameleonvision.vision.enums;
+
+public enum SortMode {
+    Largest,Smallest,Highest,Lowest,Rightmost,Leftmost,Centermost
+}

chameleon-server/src/main/java/com/chameleonvision/vision/enums/StreamDivisor.java

@@ -0,0 +1,14 @@
+package com.chameleonvision.vision.enums;
+
+public enum StreamDivisor {
+    NONE(1),
+    HALF(2),
+    QUARTER(4),
+    SIXTH(6);
+
+    public final Integer value;
+
+    StreamDivisor(int value) {
+        this.value = value;
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/enums/TargetGroup.java

@@ -0,0 +1,6 @@
+package com.chameleonvision.vision.enums;
+
+public enum TargetGroup {
+    Single,
+    Dual
+}

chameleon-server/src/main/java/com/chameleonvision/vision/enums/TargetIntersection.java

@@ -0,0 +1,5 @@
+package com.chameleonvision.vision.enums;
+
+public enum TargetIntersection {
+    None,Up,Down,Left,Right
+}

chameleon-server/src/main/java/com/chameleonvision/vision/image/CaptureProperties.java

@@ -0,0 +1,21 @@
+package com.chameleonvision.vision.image;
+
+import com.chameleonvision.vision.camera.CaptureStaticProperties;
+import edu.wpi.cscore.VideoMode;
+import org.opencv.core.Mat;
+
+public class CaptureProperties {
+
+    protected CaptureStaticProperties staticProperties;
+
+    protected CaptureProperties() {
+    }
+
+    public CaptureProperties(Mat staticImage, double fov) {
+        staticProperties = new CaptureStaticProperties(new VideoMode(0, staticImage.cols(), staticImage.rows(), 99999), staticImage.cols(), staticImage.rows(), fov);
+    }
+
+    public CaptureStaticProperties getStaticProperties() {
+        return staticProperties;
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/image/ImageCapture.java

@@ -0,0 +1,12 @@
+package com.chameleonvision.vision.image;
+
+import org.apache.commons.lang3.tuple.Pair;
+import org.opencv.core.Mat;
+
+public interface ImageCapture {
+    /**
+     * Get the next camera frame
+     * @return a Pair of the captured image and the Linux epoch of when the frame was grabbed (in uS)
+     */
+    Pair<Mat, Long> getFrame();
+}

chameleon-server/src/main/java/com/chameleonvision/vision/image/StaticImageCapture.java

@@ -0,0 +1,32 @@
+package com.chameleonvision.vision.image;
+
+import org.apache.commons.lang3.tuple.Pair;
+import org.opencv.core.Mat;
+import org.opencv.imgcodecs.Imgcodecs;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+public class StaticImageCapture implements ImageCapture {
+
+    private final Mat image = new Mat();
+
+    public StaticImageCapture(Path imagePath) {
+        if (!Files.exists(imagePath)) throw new RuntimeException("Invalid path for image!");
+
+        Mat tempMat = new Mat();
+
+        try {
+            tempMat = Imgcodecs.imread(imagePath.toString());
+        } catch (Exception e) {
+            System.err.println("Failed to read image!");
+        } finally {
+            tempMat.copyTo(image);
+        }
+    }
+
+    @Override
+    public Pair<Mat, Long> getFrame() {
+        return Pair.of(image, System.nanoTime());
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/pipeline/CVPipeline.java

@@ -0,0 +1,35 @@
+package com.chameleonvision.vision.pipeline;
+
+import com.chameleonvision.vision.camera.CameraCapture;
+import org.opencv.core.Mat;
+
+/**
+ *
+ * @param <R> Pipeline result type
+ */
+public abstract class CVPipeline<R extends CVPipelineResult, S extends CVPipelineSettings> {
+    protected Mat outputMat = new Mat();
+    CameraCapture cameraCapture;
+    public S settings;
+
+    protected CVPipeline(S settings) {
+        this.settings = settings;
+    }
+
+    protected CVPipeline(String pipelineName, S settings) {
+        this.settings = settings;
+        settings.nickname = pipelineName;
+    }
+
+    public void initPipeline(CameraCapture camera) {
+        cameraCapture = camera;
+        cameraCapture.setExposure((int) settings.exposure);
+        cameraCapture.setBrightness((int) settings.brightness);
+        cameraCapture.setGain((int) settings.gain);
+    }
+    abstract public R runPipeline(Mat inputMat);
+
+    public boolean is3D() {
+        return (this instanceof CVPipeline3d);
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/pipeline/CVPipeline2d.java

@@ -0,0 +1,201 @@
+package com.chameleonvision.vision.pipeline;
+
+import com.chameleonvision.Main;
+import com.chameleonvision.vision.camera.CameraCapture;
+import com.chameleonvision.vision.camera.CaptureStaticProperties;
+import com.chameleonvision.vision.pipeline.pipes.*;
+import org.apache.commons.lang3.tuple.Pair;
+import org.opencv.core.*;
+
+import java.util.List;
+
+import static com.chameleonvision.vision.pipeline.CVPipeline2d.*;
+
+@SuppressWarnings("WeakerAccess")
+public class CVPipeline2d extends CVPipeline<CVPipeline2dResult, CVPipeline2dSettings> {
+
+    private Mat rawCameraMat = new Mat();
+
+    private RotateFlipPipe rotateFlipPipe;
+    private BlurPipe blurPipe;
+    private ErodeDilatePipe erodeDilatePipe;
+    private HsvPipe hsvPipe;
+    private FindContoursPipe findContoursPipe;
+    private FilterContoursPipe filterContoursPipe;
+    private SpeckleRejectPipe speckleRejectPipe;
+    private GroupContoursPipe groupContoursPipe;
+    private SortContoursPipe sortContoursPipe;
+    private Collect2dTargetsPipe collect2dTargetsPipe;
+    private Draw2dContoursPipe.Draw2dContoursSettings draw2dContoursSettings;
+    private Draw2dContoursPipe draw2dContoursPipe;
+    private OutputMatPipe outputMatPipe;
+
+    private String pipelineTimeString = "";
+    private CaptureStaticProperties camProps;
+    private Scalar hsvLower, hsvUpper;
+
+    public CVPipeline2d() {
+        super(new CVPipeline2dSettings());
+    }
+
+    public CVPipeline2d(String name) {
+        super(name, new CVPipeline2dSettings());
+    }
+
+    public CVPipeline2d(CVPipeline2dSettings settings) {
+        super(settings);
+    }
+
+    @Override
+    public void initPipeline(CameraCapture process) {
+        super.initPipeline(process);
+
+        camProps = cameraCapture.getProperties().getStaticProperties();
+        hsvLower = new Scalar(settings.hue.get(0).intValue(), settings.saturation.get(0).intValue(), settings.value.get(0).intValue());
+        hsvUpper = new Scalar(settings.hue.get(1).intValue(), settings.saturation.get(1).intValue(), settings.value.get(1).intValue());
+
+        rotateFlipPipe = new RotateFlipPipe(settings.rotationMode, settings.flipMode);
+        blurPipe = new BlurPipe(5);
+        erodeDilatePipe = new ErodeDilatePipe(settings.erode, settings.dilate, 7);
+        hsvPipe = new HsvPipe(hsvLower, hsvUpper);
+        findContoursPipe = new FindContoursPipe();
+        filterContoursPipe = new FilterContoursPipe(settings.area, settings.ratio, settings.extent, camProps);
+        speckleRejectPipe = new SpeckleRejectPipe(settings.speckle.doubleValue());
+        groupContoursPipe = new GroupContoursPipe(settings.targetGroup, settings.targetIntersection);
+        sortContoursPipe = new SortContoursPipe(settings.sortMode, camProps, 5);
+        collect2dTargetsPipe = new Collect2dTargetsPipe(settings.calibrationMode, settings.point,
+                settings.dualTargetCalibrationM, settings.dualTargetCalibrationB, camProps);
+        draw2dContoursSettings = new Draw2dContoursPipe.Draw2dContoursSettings();
+        // TODO: make settable from UI? config?
+        draw2dContoursSettings.showCentroid = false;
+        draw2dContoursSettings.showCrosshair = true;
+        draw2dContoursSettings.boxOutlineSize = 2;
+        draw2dContoursSettings.showRotatedBox = true;
+        draw2dContoursSettings.showMaximumBox = true;
+        draw2dContoursSettings.showMultiple = settings.multiple;
+
+        draw2dContoursPipe = new Draw2dContoursPipe(draw2dContoursSettings, camProps);
+        outputMatPipe = new OutputMatPipe(settings.isBinary);
+    }
+
+    @Override
+    public CVPipeline2dResult runPipeline(Mat inputMat) {
+        long totalPipelineTimeNanos = 0;
+        long pipelineStartTimeNanos = System.nanoTime();
+
+        if (cameraCapture == null) {
+            throw new RuntimeException("Pipeline was not initialized before being run!");
+        }
+
+        // TODO (HIGH) find the source of the random NPE
+        if (settings == null) {
+            throw new RuntimeException("settings was not initialized!");
+        }
+        if (inputMat.cols() <= 1) {
+            throw new RuntimeException("Input Mat is empty!");
+        }
+
+        pipelineTimeString = "";
+
+        inputMat.copyTo(rawCameraMat);
+
+        // prepare pipes
+        camProps = cameraCapture.getProperties().getStaticProperties();
+        hsvLower = new Scalar(settings.hue.get(0).intValue(), settings.saturation.get(0).intValue(), settings.value.get(0).intValue());
+        hsvUpper = new Scalar(settings.hue.get(1).intValue(), settings.saturation.get(1).intValue(), settings.value.get(1).intValue());
+        rotateFlipPipe.setConfig(settings.rotationMode, settings.flipMode);
+        blurPipe.setConfig(0);
+        erodeDilatePipe.setConfig(settings.erode, settings.dilate, 7);
+        hsvPipe.setConfig(hsvLower, hsvUpper);
+        filterContoursPipe.setConfig(settings.area, settings.ratio, settings.extent, camProps);
+        speckleRejectPipe.setConfig(settings.speckle.doubleValue());
+        groupContoursPipe.setConfig(settings.targetGroup, settings.targetIntersection);
+        sortContoursPipe.setConfig(settings.sortMode, camProps, 5);
+        collect2dTargetsPipe.setConfig(settings.calibrationMode, settings.point,
+                settings.dualTargetCalibrationM, settings.dualTargetCalibrationB, camProps);
+        draw2dContoursPipe.setConfig(settings.multiple, camProps);
+        outputMatPipe.setConfig(settings.isBinary);
+
+        long pipeInitTimeNanos = System.nanoTime() - pipelineStartTimeNanos;
+
+        // run pipes
+        Pair<Mat, Long> rotateFlipResult = rotateFlipPipe.run(inputMat);
+        totalPipelineTimeNanos += rotateFlipResult.getRight();
+
+        Pair<Mat, Long> blurResult = blurPipe.run(rotateFlipResult.getLeft());
+        totalPipelineTimeNanos += blurResult.getRight();
+
+        Pair<Mat, Long> erodeDilateResult = erodeDilatePipe.run(blurResult.getLeft());
+        totalPipelineTimeNanos += erodeDilateResult.getRight();
+
+        Pair<Mat, Long> hsvResult = hsvPipe.run(erodeDilateResult.getLeft());
+        totalPipelineTimeNanos += hsvResult.getRight();
+
+        Pair<List<MatOfPoint>, Long> findContoursResult = findContoursPipe.run(hsvResult.getLeft());
+        totalPipelineTimeNanos += findContoursResult.getRight();
+
+        Pair<List<MatOfPoint>, Long> filterContoursResult = filterContoursPipe.run(findContoursResult.getLeft());
+        totalPipelineTimeNanos += filterContoursResult.getRight();
+
+        Pair<List<MatOfPoint>, Long> speckleRejectResult = speckleRejectPipe.run(filterContoursResult.getLeft());
+        totalPipelineTimeNanos += speckleRejectResult.getRight();
+
+        Pair<List<RotatedRect>, Long> groupContoursResult = groupContoursPipe.run(speckleRejectResult.getLeft());
+        totalPipelineTimeNanos += groupContoursResult.getRight();
+
+        Pair<List<RotatedRect>, Long> sortContoursResult = sortContoursPipe.run(groupContoursResult.getLeft());
+        totalPipelineTimeNanos += sortContoursResult.getRight();
+
+        Pair<List<Target2d>, Long> collect2dTargetsResult = collect2dTargetsPipe.run(Pair.of(sortContoursResult.getLeft(), camProps));
+        totalPipelineTimeNanos += collect2dTargetsResult.getRight();
+
+        // takes pair of (Mat of original camera image (8UC3), Mat of HSV thresholded image(8UC1))
+        Pair<Mat, Long> outputMatResult = outputMatPipe.run(Pair.of(rotateFlipResult.getLeft(), hsvResult.getLeft()));
+        totalPipelineTimeNanos += outputMatResult.getRight();
+
+        // takes pair of (Mat to draw on, List<RotatedRect> of sorted contours)
+        Pair<Mat, Long> draw2dContoursResult = draw2dContoursPipe.run(Pair.of(outputMatResult.getLeft(), sortContoursResult.getLeft()));
+        totalPipelineTimeNanos += draw2dContoursResult.getRight();
+
+        if (Main.testMode) {
+            pipelineTimeString += String.format("PipeInit: %.2fms, ", pipeInitTimeNanos / 1000000.0);
+            pipelineTimeString += String.format("RotateFlip: %.2fms, ", rotateFlipResult.getRight() / 1000000.0);
+            pipelineTimeString += String.format("Blur: %.2fms, ", blurResult.getRight() / 1000000.0);
+            pipelineTimeString += String.format("ErodeDilate: %.2fms, ", erodeDilateResult.getRight() / 1000000.0);
+            pipelineTimeString += String.format("HSV: %.2fms, ", hsvResult.getRight() / 1000000.0);
+            pipelineTimeString += String.format("FindContours: %.2fms, ", findContoursResult.getRight() / 1000000.0);
+            pipelineTimeString += String.format("FilterContours: %.2fms, ", filterContoursResult.getRight() / 1000000.0);
+            pipelineTimeString += String.format("SpeckleReject: %.2fms, ", speckleRejectResult.getRight() / 1000000.0);
+            pipelineTimeString += String.format("GroupContours: %.2fms, ", groupContoursResult.getRight() / 1000000.0);
+            pipelineTimeString += String.format("SortContours: %.2fms, ", sortContoursResult.getRight() / 1000000.0);
+            pipelineTimeString += String.format("Collect2dTargets: %.2fms, ", collect2dTargetsResult.getRight() / 1000000.0);
+            pipelineTimeString += String.format("OutputMat: %.2fms, ", outputMatResult.getRight() / 1000000.0);
+            pipelineTimeString += String.format("Draw2dContours: %.2fms, ", draw2dContoursResult.getRight() / 1000000.0);
+
+            System.out.println(pipelineTimeString);
+            double totalPipelineTimeMillis = totalPipelineTimeNanos / 1000000.0;
+            double totalPipelineTimeFPS = 1.0 / (totalPipelineTimeMillis / 1000.0);
+            double truePipelineTimeMillis = (System.nanoTime() - pipelineStartTimeNanos) / 1000000.0;
+            double truePipelineFPS = 1.0 / (truePipelineTimeMillis / 1000.0);
+            System.out.printf("Pipeline processed in %.3fms (%.2fFPS), ", totalPipelineTimeMillis, totalPipelineTimeFPS);
+            System.out.printf("full pipeline run time was %.3fms (%.2fFPS)\n", truePipelineTimeMillis, truePipelineFPS);
+        }
+
+        return new CVPipeline2dResult(collect2dTargetsResult.getLeft(), draw2dContoursResult.getLeft(), totalPipelineTimeNanos);
+    }
+
+    public static class CVPipeline2dResult extends CVPipelineResult<Target2d> {
+        public CVPipeline2dResult(List<Target2d> targets, Mat outputMat, long processTimeNanos) {
+            super(targets, outputMat, processTimeNanos);
+        }
+    }
+
+    public static class Target2d {
+        public double calibratedX = 0.0;
+        public double calibratedY = 0.0;
+        public double pitch = 0.0;
+        public double yaw = 0.0;
+        public double area = 0.0;
+        public RotatedRect rawPoint;
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/pipeline/CVPipeline2dSettings.java

@@ -0,0 +1,30 @@
+package com.chameleonvision.vision.pipeline;
+
+import com.chameleonvision.vision.enums.CalibrationMode;
+import com.chameleonvision.vision.enums.SortMode;
+import com.chameleonvision.vision.enums.TargetGroup;
+import com.chameleonvision.vision.enums.TargetIntersection;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class CVPipeline2dSettings extends CVPipelineSettings {
+    public List<Number> hue = Arrays.asList(50, 180);
+    public List<Number> saturation = Arrays.asList(50, 255);
+    public List<Number> value = Arrays.asList(50, 255);
+    public boolean erode = false;
+    public boolean dilate = false;
+    public List<Number> area = Arrays.asList(0.0, 100.0);
+    public List<Number> ratio = Arrays.asList(0.0, 20.0);
+    public List<Number> extent = Arrays.asList(0, 100);
+    public Number speckle = 5;
+    public boolean isBinary = false;
+    public SortMode sortMode = SortMode.Largest;
+    public boolean multiple = false;
+    public TargetGroup targetGroup = TargetGroup.Single;
+    public TargetIntersection targetIntersection = TargetIntersection.Up;
+    public List<Number> point = Arrays.asList(0, 0);
+    public CalibrationMode calibrationMode = CalibrationMode.None;
+    public double dualTargetCalibrationM = 1;
+    public double dualTargetCalibrationB = 0;
+}

chameleon-server/src/main/java/com/chameleonvision/vision/pipeline/CVPipeline3d.java

@@ -0,0 +1,35 @@
+package com.chameleonvision.vision.pipeline;
+
+import org.opencv.core.Mat;
+
+import java.util.List;
+
+import static com.chameleonvision.vision.pipeline.CVPipeline3d.*;
+
+public class CVPipeline3d extends CVPipeline<CVPipeline3dResult, CVPipeline3dSettings> {
+
+
+    protected CVPipeline3d(CVPipeline3dSettings settings) {
+        super(settings);
+    }
+
+    CVPipeline3d() {
+        super(new CVPipeline3dSettings());
+    }
+
+    @Override
+    public CVPipeline3dResult runPipeline(Mat inputMat) {
+        return null;
+    }
+
+
+    public static class CVPipeline3dResult extends CVPipelineResult<Target3d> {
+        public CVPipeline3dResult(List<Target3d> targets, Mat outputMat, long processTime) {
+            super(targets, outputMat, processTime);
+        }
+    }
+
+    public static class Target3d extends CVPipeline2d.Target2d {
+        // TODO: (2.1) Define 3d-specific target data
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/pipeline/CVPipeline3dSettings.java

@@ -0,0 +1,7 @@
+package com.chameleonvision.vision.pipeline;
+
+public class CVPipeline3dSettings extends CVPipeline2dSettings {
+    // TODO: (2.1) define 3d-specific pipeline settings
+    // add 3d-specific property to ensure serializing/deserializing works
+    public boolean placeholder = false;
+}

chameleon-server/src/main/java/com/chameleonvision/vision/pipeline/CVPipelineResult.java

@@ -0,0 +1,24 @@
+package com.chameleonvision.vision.pipeline;
+
+import org.opencv.core.Mat;
+
+import java.util.List;
+
+public abstract class CVPipelineResult<T> {
+    public final List<T> targets;
+    public final boolean hasTarget;
+    public final Mat outputMat = new Mat();
+    public final long processTime;
+    public long imageTimestamp = 0;
+
+    public CVPipelineResult(List<T> targets, Mat outputMat, long processTime) {
+        this.targets = targets;
+        hasTarget = targets != null && !targets.isEmpty();
+        outputMat.copyTo(this.outputMat);
+        this.processTime = processTime;
+    }
+
+    public void setTimestamp(long timestamp) {
+        imageTimestamp = timestamp;
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/pipeline/CVPipelineSettings.java

@@ -0,0 +1,18 @@
+package com.chameleonvision.vision.pipeline;
+
+import com.chameleonvision.vision.enums.ImageFlipMode;
+import com.chameleonvision.vision.enums.ImageRotationMode;
+import com.chameleonvision.vision.enums.StreamDivisor;
+
+@SuppressWarnings("ALL")
+public class CVPipelineSettings {
+    public int index = 0;
+    public ImageFlipMode flipMode = ImageFlipMode.NONE;
+    public ImageRotationMode rotationMode = ImageRotationMode.DEG_0;
+    public String nickname = "New Pipeline";
+    public double exposure = 50.0;
+    public double brightness = 50.0;
+    public double gain = 0;
+    public int videoModeIndex = 0;
+    public StreamDivisor streamDivisor = StreamDivisor.NONE;
+}

chameleon-server/src/main/java/com/chameleonvision/vision/pipeline/DriverVisionPipeline.java

@@ -0,0 +1,47 @@
+package com.chameleonvision.vision.pipeline;
+
+import com.chameleonvision.vision.camera.CameraCapture;
+import com.chameleonvision.vision.pipeline.pipes.Draw2dContoursPipe;
+import org.apache.commons.lang3.tuple.Pair;
+import org.opencv.core.Mat;
+import org.opencv.core.RotatedRect;
+
+import java.util.List;
+
+import static com.chameleonvision.vision.pipeline.DriverVisionPipeline.DriverPipelineResult;
+
+public class DriverVisionPipeline extends CVPipeline<DriverPipelineResult, CVPipelineSettings> {
+
+    private Draw2dContoursPipe draw2dContoursPipe;
+    private Draw2dContoursPipe.Draw2dContoursSettings draw2dContoursSettings = new Draw2dContoursPipe.Draw2dContoursSettings();
+    private final List<RotatedRect> blankList = List.of();
+
+    public DriverVisionPipeline(CVPipelineSettings settings) {
+        super(settings);
+        settings.index = -1;
+    }
+
+    @Override
+    public void initPipeline(CameraCapture capture) {
+        super.initPipeline(capture);
+        draw2dContoursSettings.showCrosshair = true;
+        draw2dContoursPipe = new Draw2dContoursPipe(draw2dContoursSettings, cameraCapture.getProperties().getStaticProperties());
+    }
+
+    @Override
+    public DriverPipelineResult runPipeline(Mat inputMat) {
+
+        inputMat.copyTo(outputMat);
+
+        draw2dContoursPipe.setConfig(false, cameraCapture.getProperties().getStaticProperties());
+        draw2dContoursPipe.run(Pair.of(outputMat, blankList)).getLeft().copyTo(outputMat);
+
+        return new DriverPipelineResult(null, outputMat, 0);
+    }
+
+    public static class DriverPipelineResult extends CVPipelineResult<Void> {
+        public DriverPipelineResult(List<Void> targets, Mat outputMat, long processTime) {
+            super(targets, outputMat, processTime);
+        }
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/pipeline/PipelineManager.java

@@ -0,0 +1,215 @@
+package com.chameleonvision.vision.pipeline;
+
+import com.chameleonvision.config.CameraConfig;
+import com.chameleonvision.config.ConfigManager;
+import com.chameleonvision.vision.VisionManager;
+import com.chameleonvision.vision.VisionProcess;
+import com.chameleonvision.web.SocketHandler;
+import edu.wpi.first.networktables.NetworkTableEntry;
+
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+
+@SuppressWarnings("WeakerAccess")
+public class PipelineManager {
+
+    private static final int DRIVERMODE_INDEX = -1;
+
+    public final LinkedList<CVPipeline> pipelines = new LinkedList<>();
+
+    public final CVPipeline driverModePipeline = new DriverVisionPipeline(new CVPipelineSettings());
+
+    private final VisionProcess parentProcess;
+    private int lastPipelineIndex;
+    private int currentPipelineIndex;
+    public NetworkTableEntry ntIndexEntry;
+
+    public PipelineManager(VisionProcess visionProcess, List<CVPipelineSettings> loadedPipelineSettings) {
+        parentProcess = visionProcess;
+        if (loadedPipelineSettings == null || loadedPipelineSettings.size() == 0) {
+            pipelines.add(new CVPipeline2d("New Pipeline"));
+        } else {
+            for (CVPipelineSettings setting : loadedPipelineSettings) {
+                addInternalPipeline(setting);
+            }
+        }
+        driverModePipeline.initPipeline(visionProcess.getCamera());
+        setCurrentPipeline(0);
+    }
+
+    private void reassignIndexes() {
+        pipelines.sort(IndexComparator);
+        for (int i = 0; i < pipelines.size(); i++) {
+            pipelines.get(i).settings.index = i;
+        }
+    }
+
+    private CameraConfig getConfig(VisionProcess process) {
+        return VisionManager.getCameraConfig(process);
+    }
+
+    private CameraConfig getConfig() {
+        return getConfig(parentProcess);
+    }
+
+    private void savePipelineConfig(CVPipelineSettings setting) {
+        getConfig().pipelineConfig.save(setting);
+    }
+
+    private void deletePipelineConfig(CVPipelineSettings setting) {
+        getConfig().pipelineConfig.delete(setting);
+    }
+
+    private void renamePipelineConfig(CVPipelineSettings setting, String newName) {
+        getConfig().pipelineConfig.rename(setting, newName);
+    }
+
+    public void saveAllPipelines() {
+        pipelines.parallelStream().map(pipeline -> pipeline.settings).forEach(this::savePipelineConfig);
+    }
+
+    private void addInternalPipeline(CVPipelineSettings setting) {
+        if (setting instanceof CVPipeline3dSettings) {
+            pipelines.add(new CVPipeline3d((CVPipeline3dSettings) setting));
+        } else if (setting instanceof CVPipeline2dSettings) {
+            pipelines.add(new CVPipeline2d((CVPipeline2dSettings) setting));
+        } else {
+            System.out.println("Non 2D/3D pipelines not supported!");
+        }
+        reassignIndexes();
+    }
+
+    public void setDriverMode(boolean driverMode) {
+        if (driverMode) {
+            setCurrentPipeline(DRIVERMODE_INDEX);
+        } else {
+            setCurrentPipeline(lastPipelineIndex);
+        }
+    }
+
+    public boolean getDriverMode() {
+        return currentPipelineIndex == DRIVERMODE_INDEX;
+    }
+
+    public int getCurrentPipelineIndex() {
+        return currentPipelineIndex;
+    }
+
+    public CVPipeline getCurrentPipeline() {
+        if (currentPipelineIndex <= DRIVERMODE_INDEX) {
+            return driverModePipeline;
+        } else {
+            return pipelines.get(currentPipelineIndex);
+        }
+    }
+
+    public void setCurrentPipeline(int index) {
+        CVPipeline newPipeline;
+        if (index == DRIVERMODE_INDEX) {
+            newPipeline = driverModePipeline;
+
+            // if we're changing into driver mode, try to set the nt entry to frue
+            parentProcess.setDriverModeEntry(true);
+        } else {
+            newPipeline = pipelines.get(index);
+
+            // if we're switching out of driver mode, try to set the nt entry to false
+            parentProcess.setDriverModeEntry(false);
+        }
+        if (newPipeline != null) {
+            lastPipelineIndex = currentPipelineIndex;
+            currentPipelineIndex = index;
+            getCurrentPipeline().initPipeline(parentProcess.getCamera());
+
+            if(ConfigManager.settings.currentCamera.equals(parentProcess.getCamera().getProperties().name)) {
+                ConfigManager.settings.currentPipeline = currentPipelineIndex;
+
+                HashMap<String, Object> pipeChange = new HashMap<>();
+                pipeChange.put("currentPipeline", currentPipelineIndex);
+                SocketHandler.broadcastMessage(pipeChange);
+                try {
+                    SocketHandler.sendFullSettings();
+                } catch (Exception e) {
+                    // avoid NullPointerException when run before threads start
+                }
+            }
+            newPipeline.initPipeline(parentProcess.getCamera());
+            if(ntIndexEntry != null) {
+                ntIndexEntry.setDouble(index);
+            }
+        }
+    }
+
+    public void addPipeline(CVPipelineSettings setting) {
+        addInternalPipeline(setting);
+        savePipelineConfig(setting);
+    }
+
+    public void addPipeline(CVPipeline pipeline) {
+        pipelines.add(pipeline);
+        reassignIndexes();
+        savePipelineConfig(pipeline.settings);
+    }
+
+    public void addNewPipeline(boolean is3D) {
+        CVPipeline newPipeline;
+        if (!is3D) {
+            newPipeline = new CVPipeline2d();
+        } else {
+            newPipeline = new CVPipeline3d();
+        }
+        newPipeline.settings.index = pipelines.size();
+        addPipeline(newPipeline);
+    }
+
+    public CVPipeline getPipeline(int index) {
+        return pipelines.get(index);
+    }
+
+    public void duplicatePipeline(CVPipelineSettings pipeline) {
+        duplicatePipeline(pipeline, parentProcess);
+    }
+
+    public void duplicatePipeline(CVPipelineSettings pipeline, VisionProcess destinationProcess) {
+        pipeline.index = destinationProcess.pipelineManager.pipelines.size();
+        pipeline.nickname += "(Copy)";
+        destinationProcess.pipelineManager.addPipeline(pipeline);
+    }
+
+    public void renameCurrentPipeline(String newName) {
+        CVPipelineSettings settings = getCurrentPipeline().settings;
+        settings.nickname = newName;
+        renamePipelineConfig(settings, newName);
+    }
+
+    public void deleteCurrentPipeline() {
+        deletePipeline(currentPipelineIndex);
+    }
+
+    private void deletePipeline(int index) {
+        if (index == currentPipelineIndex) {
+            currentPipelineIndex -= 1;
+        }
+        deletePipelineConfig(getPipeline(index).settings);
+        pipelines.remove(index);
+        reassignIndexes();
+    }
+
+    public void saveDriverModeConfig() {
+        getConfig().saveDriverMode(driverModePipeline.settings);
+    }
+
+    private static final Comparator<CVPipeline> IndexComparator = (o1, o2) -> {
+        int o1Index = o1.settings.index;
+        int o2Index = o2.settings.index;
+
+        if (o1Index == o2Index) {
+            return 0;
+        } else if (o1Index < o2Index) {
+            return -1;
+        }
+        return 1;
+    };
+}

chameleon-server/src/main/java/com/chameleonvision/vision/pipeline/pipes/BlurPipe.java

@@ -0,0 +1,44 @@
+package com.chameleonvision.vision.pipeline.pipes;
+
+import org.apache.commons.lang3.tuple.Pair;
+import org.opencv.core.CvException;
+import org.opencv.core.Mat;
+import org.opencv.core.Size;
+import org.opencv.imgproc.Imgproc;
+
+public class BlurPipe implements Pipe<Mat, Mat> {
+
+    private int blurSize;
+
+    private Mat processBuffer = new Mat();
+    private Mat outputMat = new Mat();
+
+    public BlurPipe(int blurSize) {
+        this.blurSize = blurSize;
+    }
+
+    public void setConfig(int blurSize) {
+        this.blurSize = blurSize;
+    }
+
+    @Override
+    public Pair<Mat, Long> run(Mat input) {
+        long processStartNanos = System.nanoTime();
+
+        if (blurSize > 0) {
+            input.copyTo(processBuffer);
+            try {
+                Imgproc.blur(processBuffer, processBuffer, new Size(blurSize, blurSize));
+                processBuffer.copyTo(outputMat);
+                processBuffer.release();
+            } catch (CvException e) {
+                System.err.println("(BlurPipe) Exception thrown by OpenCV: \n" + e.getMessage());
+            }
+        } else {
+            input.copyTo(outputMat);
+        }
+
+        long processTime = System.nanoTime() - processStartNanos;
+        return Pair.of(outputMat, processTime);
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/pipeline/pipes/Collect2dTargetsPipe.java

@@ -0,0 +1,88 @@
+package com.chameleonvision.vision.pipeline.pipes;
+
+import com.chameleonvision.vision.camera.CaptureStaticProperties;
+import com.chameleonvision.vision.pipeline.CVPipeline2d;
+import com.chameleonvision.vision.enums.CalibrationMode;
+import org.apache.commons.lang3.tuple.Pair;
+import org.apache.commons.math3.util.FastMath;
+import org.opencv.core.Mat;
+import org.opencv.core.RotatedRect;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Collect2dTargetsPipe implements Pipe<Pair<List<RotatedRect>, CaptureStaticProperties>, List<CVPipeline2d.Target2d>> {
+
+    private CalibrationMode calibrationMode;
+    private CaptureStaticProperties camProps;
+    private List<Number> calibrationPoint;
+    private double calibrationM, calibrationB;
+
+    private List<CVPipeline2d.Target2d> targets = new ArrayList<>();
+
+    public Collect2dTargetsPipe(CalibrationMode calibrationMode, List<Number> calibrationPoint,
+                                double calibrationM, double calibrationB, CaptureStaticProperties camProps) {
+        this.calibrationMode = calibrationMode;
+        this.camProps = camProps;
+        this.calibrationPoint = calibrationPoint;
+        this.calibrationM = calibrationM;
+        this.calibrationB = calibrationB;
+    }
+
+    public void setConfig(CalibrationMode calibrationMode, List<Number> calibrationPoint,
+                          double calibrationM, double calibrationB, CaptureStaticProperties camProps) {
+        this.calibrationMode = calibrationMode;
+        this.camProps = camProps;
+        this.calibrationPoint = calibrationPoint;
+        this.calibrationM = calibrationM;
+        this.calibrationB = calibrationB;
+    }
+
+    @Override
+    public Pair<List<CVPipeline2d.Target2d>, Long> run(Pair<List<RotatedRect>, CaptureStaticProperties> inputPair) {
+        long processStartNanos = System.nanoTime();
+
+        targets.clear();
+        var input = inputPair.getLeft();
+        var imageArea = inputPair.getRight().imageArea;
+
+        if (input.size() > 0) {
+            for (RotatedRect r : input) {
+                CVPipeline2d.Target2d t = new CVPipeline2d.Target2d();
+                t.rawPoint = r;
+                switch (calibrationMode) {
+                    case None:
+                        t.calibratedX = camProps.centerX;
+                        t.calibratedY = camProps.centerY;
+                        break;
+                    case Single:
+                        t.calibratedX = calibrationPoint.get(0).doubleValue();
+                        t.calibratedY = calibrationPoint.get(1).doubleValue();
+                        break;
+                    case Dual:
+                        t.calibratedX = (r.center.y - calibrationB) / calibrationM;
+                        t.calibratedY = (r.center.x * calibrationM) + calibrationB;
+                        break;
+                }
+
+                t.pitch = calculatePitch(r.center.y, t.calibratedY);
+                t.yaw = calculateYaw(r.center.x, t.calibratedX);
+                t.area = r.size.area() / imageArea;
+
+                targets.add(t);
+            }
+        }
+
+        long processTime = System.nanoTime() - processStartNanos;
+        return Pair.of(targets, processTime);
+    }
+
+    private double calculatePitch(double pixelY, double centerY) {
+        double pitch = FastMath.toDegrees(FastMath.atan((pixelY - centerY) / camProps.verticalFocalLength));
+        return (pitch * -1);
+    }
+
+    private double calculateYaw(double pixelX, double centerX) {
+        return FastMath.toDegrees(FastMath.atan((pixelX - centerX) / camProps.horizontalFocalLength));
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/pipeline/pipes/Draw2dContoursPipe.java

@@ -0,0 +1,106 @@
+package com.chameleonvision.vision.pipeline.pipes;
+
+import com.chameleonvision.vision.camera.CaptureStaticProperties;
+import com.chameleonvision.util.Helpers;
+import org.apache.commons.lang3.tuple.Pair;
+import org.opencv.core.Point;
+import org.opencv.core.*;
+import org.opencv.imgproc.Imgproc;
+
+import java.awt.*;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Draw2dContoursPipe implements Pipe<Pair<Mat, List<RotatedRect>>, Mat> {
+
+    private final Draw2dContoursSettings settings;
+    private CaptureStaticProperties camProps;
+
+    private Mat processBuffer = new Mat();
+    private Mat outputMat = new Mat();
+
+    private Point[] vertices = new Point[4];
+    private List<MatOfPoint> drawnContours = new ArrayList<>();
+    @SuppressWarnings("FieldCanBeLocal")
+    private Point xMax = new Point(), xMin = new Point(), yMax = new Point(), yMin = new Point();
+
+
+    public Draw2dContoursPipe(Draw2dContoursSettings settings, CaptureStaticProperties camProps) {
+        this.settings = settings;
+        this.camProps = camProps;
+    }
+
+    public void setConfig(boolean showMultiple,CaptureStaticProperties captureProps) {
+        settings.showMultiple = showMultiple;
+        camProps = captureProps;
+    }
+
+    @Override
+    public Pair<Mat, Long> run(Pair<Mat, List<RotatedRect>> input) {
+        long processStartNanos = System.nanoTime();
+
+        if (settings.showCrosshair || settings.showCentroid || settings.showMaximumBox || settings.showRotatedBox) {
+            input.getLeft().copyTo(processBuffer);
+
+            if (input.getRight().size() > 0) {
+                for (int i = 0; i < input.getRight().size(); i++) {
+                    if (i != 0 && !settings.showMultiple){
+                        break;
+                    }
+                    RotatedRect r = input.getRight().get(i);
+                    if (r == null) continue;
+
+                    drawnContours.forEach(Mat::release);
+                    drawnContours.clear();
+
+                    r.points(vertices);
+                    MatOfPoint contour = new MatOfPoint(vertices);
+                    drawnContours.add(contour);
+
+                    if (settings.showCentroid) {
+                        Imgproc.circle(processBuffer, r.center, 3, Helpers.colorToScalar(settings.centroidColor));
+                    }
+
+                    if (settings.showRotatedBox) {
+                        Imgproc.drawContours(processBuffer, drawnContours, 0, Helpers.colorToScalar(settings.rotatedBoxColor), settings.boxOutlineSize);
+                    }
+
+                    if (settings.showMaximumBox) {
+                        Rect box = Imgproc.boundingRect(contour);
+                        Imgproc.rectangle(processBuffer, new Point(box.x, box.y), new Point((box.x + box.width), (box.y + box.height)), Helpers.colorToScalar(settings.maximumBoxColor), settings.boxOutlineSize);
+                    }
+                }
+            }
+
+            if (settings.showCrosshair) {
+                xMax.set(new double[] {camProps.centerX + 10, camProps.centerY});
+                xMin.set(new double[] {camProps.centerX - 10, camProps.centerY});
+                yMax.set(new double[] {camProps.centerX, camProps.centerY + 10});
+                yMin.set(new double[] {camProps.centerX, camProps.centerY - 10});
+                Imgproc.line(processBuffer, xMax, xMin, Helpers.colorToScalar(settings.crosshairColor), 2);
+                Imgproc.line(processBuffer, yMax, yMin, Helpers.colorToScalar(settings.crosshairColor), 2);
+            }
+
+            processBuffer.copyTo(outputMat);
+            processBuffer.release();
+        } else {
+            input.getLeft().copyTo(outputMat);
+        }
+
+        long processTime = System.nanoTime() - processStartNanos;
+        return Pair.of(outputMat, processTime);
+    }
+
+    public static class Draw2dContoursSettings {
+        public boolean showCentroid = false;
+        public boolean showCrosshair = false;
+        public boolean showMultiple = false;
+        public int boxOutlineSize = 0;
+        public boolean showRotatedBox = false;
+        public boolean showMaximumBox = false;
+        public Color centroidColor = Color.GREEN;
+        public Color crosshairColor = Color.GREEN;
+        public Color rotatedBoxColor = Color.BLUE;
+        public Color maximumBoxColor = Color.RED;
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/pipeline/pipes/ErodeDilatePipe.java

@@ -0,0 +1,53 @@
+package com.chameleonvision.vision.pipeline.pipes;
+
+import org.apache.commons.lang3.tuple.Pair;
+import org.opencv.core.Mat;
+import org.opencv.core.Size;
+import org.opencv.imgproc.Imgproc;
+
+public class ErodeDilatePipe implements Pipe<Mat, Mat> {
+
+    private boolean erode;
+    private boolean dilate;
+    private Mat kernel;
+
+    private Mat processBuffer = new Mat();
+    private Mat outputMat = new Mat();
+
+    public ErodeDilatePipe(boolean erode, boolean dilate, int kernelSize) {
+        this.erode = erode;
+        this.dilate = dilate;
+        kernel = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(kernelSize, kernelSize));
+    }
+
+    public void setConfig(boolean erode, boolean dilate, int kernelSize) {
+        this.erode = erode;
+        this.dilate = dilate;
+        kernel = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(kernelSize, kernelSize));
+    }
+
+    @Override
+    public Pair<Mat, Long> run(Mat input) {
+        long processStartNanos = System.nanoTime();
+
+        if (erode || dilate) {
+            input.copyTo(processBuffer);
+
+            if (erode) {
+                Imgproc.erode(processBuffer, processBuffer, kernel);
+            }
+
+            if (dilate) {
+                Imgproc.dilate(processBuffer, processBuffer, kernel);
+            }
+
+            processBuffer.copyTo(outputMat);
+            processBuffer.release();
+        } else {
+            input.copyTo(outputMat);
+        }
+
+        long processTime = System.nanoTime() - processStartNanos;
+        return Pair.of(outputMat, processTime);
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/pipeline/pipes/FilterContoursPipe.java

@@ -0,0 +1,75 @@
+package com.chameleonvision.vision.pipeline.pipes;
+
+import com.chameleonvision.vision.camera.CaptureStaticProperties;
+import com.chameleonvision.util.MathHandler;
+import org.apache.commons.lang3.tuple.Pair;
+import org.opencv.core.MatOfPoint;
+import org.opencv.core.MatOfPoint2f;
+import org.opencv.core.Rect;
+import org.opencv.imgproc.Imgproc;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class FilterContoursPipe implements Pipe<List<MatOfPoint>, List<MatOfPoint>> {
+
+    private List<Number> area;
+    private List<Number> ratio;
+    private List<Number> extent;
+    private CaptureStaticProperties camProps;
+
+    private List<MatOfPoint> filteredContours = new ArrayList<>();
+
+    public FilterContoursPipe(List<Number> area, List<Number> ratio, List<Number> extent, CaptureStaticProperties camProps) {
+        this.area = area;
+        this.ratio = ratio;
+        this.extent = extent;
+        this.camProps = camProps;
+    }
+
+    public void setConfig(List<Number> area, List<Number> ratio, List<Number> extent, CaptureStaticProperties camProps) {
+        this.area = area;
+        this.ratio = ratio;
+        this.extent = extent;
+        this.camProps = camProps;
+    }
+
+    @Override
+    public Pair<List<MatOfPoint>, Long> run(List<MatOfPoint> input) {
+        long processStartNanos = System.nanoTime();
+
+        filteredContours.clear();
+
+        if (input.size() > 0) {
+            for (MatOfPoint Contour : input) {
+                try {
+                    double contourArea = Imgproc.contourArea(Contour);
+                    double AreaRatio = (contourArea / camProps.imageArea) * 100;
+                    double minArea = (MathHandler.sigmoid(area.get(0)));
+                    double maxArea = (MathHandler.sigmoid(area.get(1)));
+                    if (AreaRatio < minArea || AreaRatio > maxArea) {
+                        continue;
+                    }
+                    var rect = Imgproc.minAreaRect(new MatOfPoint2f(Contour.toArray()));
+                    double minExtent = (extent.get(0).doubleValue() * rect.size.area()) / 100;
+                    double maxExtent = (extent.get(1).doubleValue() * rect.size.area()) / 100;
+                    if (contourArea <= minExtent || contourArea >= maxExtent) {
+                        continue;
+                    }
+                    Rect bb = Imgproc.boundingRect(Contour);
+                    double aspectRatio = ((double)bb.width / bb.height);
+                    if (aspectRatio < ratio.get(0).doubleValue() || aspectRatio > ratio.get(1).doubleValue()) {
+                        continue;
+                    }
+                    filteredContours.add(Contour);
+                } catch (Exception e) {
+                    System.err.println("Error while filtering contours");
+                    e.printStackTrace();
+                }
+            }
+        }
+
+        long processTime = System.nanoTime() - processStartNanos;
+        return Pair.of(filteredContours, processTime);
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/pipeline/pipes/FindContoursPipe.java

@@ -0,0 +1,28 @@
+package com.chameleonvision.vision.pipeline.pipes;
+
+import org.apache.commons.lang3.tuple.Pair;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfPoint;
+import org.opencv.imgproc.Imgproc;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class FindContoursPipe implements Pipe<Mat, List<MatOfPoint>> {
+
+    private List<MatOfPoint> foundContours = new ArrayList<>();
+
+    public FindContoursPipe() {}
+
+    @Override
+    public Pair<List<MatOfPoint>, Long> run(Mat input) {
+        long processStartNanos = System.nanoTime();
+
+        foundContours.clear();
+
+        Imgproc.findContours(input, foundContours, new Mat(), Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_TC89_L1);
+
+        long processTime = System.nanoTime() - processStartNanos;
+        return Pair.of(foundContours, processTime);
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/pipeline/pipes/GroupContoursPipe.java

@@ -0,0 +1,165 @@
+package com.chameleonvision.vision.pipeline.pipes;
+
+import com.chameleonvision.util.MathHandler;
+import com.chameleonvision.vision.enums.TargetGroup;
+import com.chameleonvision.vision.enums.TargetIntersection;
+import org.apache.commons.lang3.tuple.Pair;
+import org.opencv.core.*;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.imgproc.Moments;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+public class GroupContoursPipe implements Pipe<List<MatOfPoint>, List<RotatedRect>> {
+
+    private static final Comparator<MatOfPoint> sortByMomentsX =
+            Comparator.comparingDouble(GroupContoursPipe::calcMomentsX);
+
+    private TargetGroup group;
+    private TargetIntersection intersection;
+
+    private List<RotatedRect> groupedContours = new ArrayList<>();
+    private MatOfPoint2f intersectMatA = new MatOfPoint2f();
+    private MatOfPoint2f intersectMatB = new MatOfPoint2f();
+
+    public GroupContoursPipe(TargetGroup group, TargetIntersection intersection) {
+        this.group = group;
+        this.intersection = intersection;
+    }
+
+    public void setConfig(TargetGroup group, TargetIntersection intersection) {
+        this.group = group;
+        this.intersection = intersection;
+    }
+
+    @Override
+    public Pair<List<RotatedRect>, Long> run(List<MatOfPoint> input) {
+        long processStartNanos = System.nanoTime();
+
+        groupedContours.clear();
+
+        if (input.size() > (group.equals(TargetGroup.Single) ? 0 : 1)) {
+
+            List<MatOfPoint> sorted = new ArrayList<>(input);
+            sorted.sort(sortByMomentsX);
+
+            Collections.reverse(sorted);
+
+            switch (group) {
+                case Single: {
+                    input.forEach(c -> {
+                        MatOfPoint2f contour = new MatOfPoint2f();
+                        contour.fromArray(c.toArray());
+                        if (contour.cols() != 0 && contour.rows() != 0) {
+                            RotatedRect rect = Imgproc.minAreaRect(contour);
+                            groupedContours.add(rect);
+                        }
+                    });
+                    break;
+                }
+                case Dual: {
+                    for (var i = 0; i < input.size(); i++) {
+                        List<Point> finalContourList = new ArrayList<>(input.get(i).toList());
+
+                        try {
+                            MatOfPoint firstContour = input.get(i);
+                            MatOfPoint secondContour = input.get(i + 1);
+
+                            if (isIntersecting(firstContour, secondContour)) {
+                                finalContourList.addAll(secondContour.toList());
+                            } else {
+                                finalContourList.clear();
+                                continue;
+                            }
+
+                            intersectMatA.release();
+                            intersectMatB.release();
+                            firstContour.release();
+                            secondContour.release();
+
+                            MatOfPoint2f contour = new MatOfPoint2f();
+                            contour.fromList(finalContourList);
+
+                            if (contour.cols() != 0 && contour.rows() != 0) {
+                                RotatedRect rect = Imgproc.minAreaRect(contour);
+                                groupedContours.add(rect);
+                            }
+                        } catch (IndexOutOfBoundsException e) {
+                            finalContourList.clear();
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+
+        long processTime = System.nanoTime() - processStartNanos;
+        return Pair.of(groupedContours, processTime);
+    }
+
+    private static double calcMomentsX(MatOfPoint c) {
+        Moments m = Imgproc.moments(c);
+        return (m.get_m10() / m.get_m00());
+    }
+
+    private boolean isIntersecting(MatOfPoint contourOne, MatOfPoint contourTwo) {
+        if (intersection.equals(TargetIntersection.None)) {
+            return true;
+        }
+
+        try {
+            intersectMatA.fromArray(contourOne.toArray());
+            intersectMatB.fromArray(contourTwo.toArray());
+            RotatedRect a = Imgproc.fitEllipse(intersectMatA);
+            RotatedRect b = Imgproc.fitEllipse(intersectMatB);
+            double mA = MathHandler.toSlope(a.angle);
+            double mB = MathHandler.toSlope(b.angle);
+            double x0A = a.center.x;
+            double y0A = a.center.y;
+            double x0B = b.center.x;
+            double y0B = b.center.y;
+            double intersectionX = ((mA * x0A) - y0A - (mB * x0B) + y0B) / (mA - mB);
+            double intersectionY = (mA * (intersectionX - x0A)) + y0A;
+            double massX = (x0A + x0B) / 2;
+            double massY = (y0A + y0B) / 2;
+            switch (intersection) {
+                case Up: {
+                    if (intersectionY < massY) {
+                        if (mA > 0 && mB < 0) {
+                            return true;
+                        }
+                    }
+                    break;
+                }
+                case Down: {
+                    if (intersectionY > massY) {
+                        if (mA < 0 && mB > 0) {
+                            return true;
+                        }
+                    }
+
+                    break;
+                }
+                case Left: {
+                    if (intersectionX < massX) {
+
+                        return true;
+                    }
+                    break;
+                }
+                case Right: {
+                    if (intersectionX > massX) {
+                        return true;
+                    }
+                    break;
+                }
+            }
+            return false;
+        } catch (Exception e) {
+            return false;
+        }
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/pipeline/pipes/HsvPipe.java

@@ -0,0 +1,48 @@
+package com.chameleonvision.vision.pipeline.pipes;
+
+import org.apache.commons.lang3.tuple.Pair;
+import org.opencv.core.Core;
+import org.opencv.core.CvException;
+import org.opencv.core.Mat;
+import org.opencv.core.Scalar;
+import org.opencv.imgproc.Imgproc;
+
+public class HsvPipe implements Pipe<Mat, Mat> {
+
+    private Scalar hsvLower;
+    private Scalar hsvUpper;
+
+    private Mat processBuffer = new Mat();
+    private Mat outputMat = new Mat();
+
+    public HsvPipe(Scalar hsvLower, Scalar hsvUpper) {
+        this.hsvLower = hsvLower;
+        this.hsvUpper = hsvUpper;
+    }
+
+    public void setConfig(Scalar hsvLower, Scalar hsvUpper) {
+        this.hsvLower = hsvLower;
+        this.hsvUpper = hsvUpper;
+    }
+
+    @Override
+    public Pair<Mat, Long> run(Mat input) {
+        long processStartNanos = System.nanoTime();
+
+        input.copyTo(processBuffer);
+
+        try {
+            Imgproc.cvtColor(processBuffer, processBuffer, Imgproc.COLOR_BGR2HSV, 3);
+            Core.inRange(processBuffer, hsvLower, hsvUpper, processBuffer);
+        } catch (CvException e) {
+            System.err.println("(HsvPipe) Exception thrown by OpenCV: \n" + e.getMessage());
+        }
+
+        processBuffer.copyTo(outputMat);
+        processBuffer.release();
+
+        long processTime = System.nanoTime() - processStartNanos;
+        return Pair.of(outputMat, processTime);
+    }
+}
+

chameleon-server/src/main/java/com/chameleonvision/vision/pipeline/pipes/OutputMatPipe.java

@@ -0,0 +1,49 @@
+package com.chameleonvision.vision.pipeline.pipes;
+
+import org.apache.commons.lang3.tuple.Pair;
+import org.opencv.core.CvException;
+import org.opencv.core.Mat;
+import org.opencv.imgproc.Imgproc;
+
+public class OutputMatPipe implements Pipe<Pair<Mat, Mat>, Mat> {
+
+    private boolean showThresholded;
+
+    private Mat processBuffer = new Mat();
+    private Mat outputMat = new Mat();
+
+    public OutputMatPipe(boolean showThresholded) {
+        this.showThresholded = showThresholded;
+    }
+
+    public void setConfig(boolean showThresholded) {
+        this.showThresholded = showThresholded;
+    }
+
+    /**
+     *
+     * @param input Input object for pipe
+     *        Left is raw camera mat (8UC3), Right is HSV threshold mat (8UC1)
+     * @return Returns desired output Mat, and processing time in nanoseconds
+     */
+    @Override
+    public Pair<Mat, Long> run(Pair<Mat, Mat> input) {
+        long processStartNanos = System.nanoTime();
+
+        if (showThresholded) {
+            try {
+                input.getRight().copyTo(processBuffer);
+                Imgproc.cvtColor(processBuffer, processBuffer, Imgproc.COLOR_GRAY2BGR, 3);
+                processBuffer.copyTo(outputMat);
+                processBuffer.release();
+            } catch (CvException e) {
+                System.err.println("(OutputMat) Exception thrown by OpenCV: \n" + e.getMessage());
+            }
+        } else {
+            input.getLeft().copyTo(outputMat);
+        }
+
+        long processTime = System.nanoTime() - processStartNanos;
+        return Pair.of(outputMat, processTime);
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/pipeline/pipes/Pipe.java

@@ -0,0 +1,13 @@
+package com.chameleonvision.vision.pipeline.pipes;
+
+import org.apache.commons.lang3.tuple.Pair;
+
+public interface Pipe<I, O> {
+    /**
+     *
+     * @param input Input object for pipe
+     * @return Returns a Pair containing the process time in Nanoseconds,
+     *         and the output object
+     */
+    Pair<O, Long> run(I input);
+}

chameleon-server/src/main/java/com/chameleonvision/vision/pipeline/pipes/RotateFlipPipe.java

@@ -0,0 +1,54 @@
+package com.chameleonvision.vision.pipeline.pipes;
+
+import com.chameleonvision.vision.enums.ImageFlipMode;
+import com.chameleonvision.vision.enums.ImageRotationMode;
+import org.apache.commons.lang3.tuple.Pair;
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+
+public class RotateFlipPipe implements Pipe<Mat, Mat> {
+
+    private ImageRotationMode rotation;
+    private ImageFlipMode flip;
+
+    private Mat processBuffer = new Mat();
+    private Mat outputMat = new Mat();
+
+    public RotateFlipPipe(ImageRotationMode rotation, ImageFlipMode flip) {
+        this.rotation = rotation;
+        this.flip = flip;
+    }
+
+    public void setConfig(ImageRotationMode rotation, ImageFlipMode flip) {
+        this.rotation = rotation;
+        this.flip = flip;
+    }
+
+    @Override
+    public Pair<Mat, Long> run(Mat input) {
+        long processStartNanos = System.nanoTime();
+
+        boolean shouldFlip = !flip.equals(ImageFlipMode.NONE);
+        boolean shouldRotate = !rotation.equals(ImageRotationMode.DEG_0);
+
+        if (shouldFlip || shouldRotate) {
+            input.copyTo(processBuffer);
+
+            if (shouldFlip) {
+                Core.flip(processBuffer, processBuffer, flip.value);
+            }
+
+            if (shouldRotate) {
+                Core.rotate(processBuffer, processBuffer, rotation.value);
+            }
+
+            processBuffer.copyTo(outputMat);
+            processBuffer.release();
+        } else {
+            input.copyTo(outputMat);
+        }
+
+        long processTime = System.nanoTime() - processStartNanos;
+        return Pair.of(outputMat, processTime);
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/pipeline/pipes/SortContoursPipe.java

@@ -0,0 +1,87 @@
+package com.chameleonvision.vision.pipeline.pipes;
+
+import com.chameleonvision.vision.camera.CaptureStaticProperties;
+import com.chameleonvision.vision.enums.SortMode;
+import org.apache.commons.lang3.tuple.Pair;
+import org.apache.commons.math3.util.FastMath;
+import org.opencv.core.RotatedRect;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+public class SortContoursPipe implements Pipe<List<RotatedRect>, List<RotatedRect>> {
+
+    private final Comparator<RotatedRect> SortByCentermostComparator = Comparator.comparingDouble(this::calcCenterDistance);
+
+    private static final Comparator<RotatedRect> SortByLargestComparator = (rect1, rect2) -> Double.compare(rect2.size.area(), rect1.size.area());
+    private static final Comparator<RotatedRect> SortBySmallestComparator = SortByLargestComparator.reversed();
+
+    private static final Comparator<RotatedRect> SortByHighestComparator = (rect1, rect2) -> Double.compare(rect2.center.y, rect1.center.y);
+    private static final Comparator<RotatedRect> SortByLowestComparator = SortByHighestComparator.reversed();
+
+    private static final Comparator<RotatedRect> SortByLeftmostComparator = Comparator.comparingDouble(rect -> rect.center.x);
+    private static final Comparator<RotatedRect> SortByRightmostComparator = SortByLeftmostComparator.reversed();
+
+    private SortMode sort;
+    private CaptureStaticProperties camProps;
+    private int maxTargets;
+
+    private List<RotatedRect> sortedContours = new ArrayList<>();
+
+    public SortContoursPipe(SortMode sort, CaptureStaticProperties camProps, int maxTargets) {
+        this.sort = sort;
+        this.camProps = camProps;
+        this.maxTargets = maxTargets;
+    }
+
+    public void setConfig(SortMode sort, CaptureStaticProperties camProps, int maxTargets) {
+        this.sort = sort;
+        this.camProps = camProps;
+        this.maxTargets = maxTargets;
+    }
+
+    @Override
+    public Pair<List<RotatedRect>, Long> run(List<RotatedRect> input) {
+        long processStartNanos = System.nanoTime();
+
+        sortedContours.clear();
+
+        if (input.size() > 0) {
+            sortedContours.addAll(input.subList(0, Math.min(input.size(), maxTargets - 1)));
+
+            switch (sort) {
+                case Largest:
+                    sortedContours.sort(SortByLargestComparator);
+                    break;
+                case Smallest:
+                    sortedContours.sort(SortBySmallestComparator);
+                    break;
+                case Highest:
+                    sortedContours.sort(SortByHighestComparator);
+                    break;
+                case Lowest:
+                    sortedContours.sort(SortByLowestComparator);
+                    break;
+                case Leftmost:
+                    sortedContours.sort(SortByLeftmostComparator);
+                    break;
+                case Rightmost:
+                    sortedContours.sort(SortByRightmostComparator);
+                    break;
+                case Centermost:
+                    sortedContours.sort(SortByCentermostComparator);
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        long processTime = System.nanoTime() - processStartNanos;
+        return Pair.of(sortedContours, processTime);
+    }
+
+    private double calcCenterDistance(RotatedRect rect) {
+        return FastMath.sqrt(FastMath.pow(camProps.centerX - rect.center.x, 2) + FastMath.pow(camProps.centerY - rect.center.y, 2));
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/vision/pipeline/pipes/SpeckleRejectPipe.java

@@ -0,0 +1,51 @@
+package com.chameleonvision.vision.pipeline.pipes;
+
+import org.apache.commons.lang3.tuple.Pair;
+import org.opencv.core.MatOfPoint;
+import org.opencv.imgproc.Imgproc;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SpeckleRejectPipe implements Pipe<List<MatOfPoint>, List<MatOfPoint>> {
+
+    private double minPercentOfAvg;
+
+    private List<MatOfPoint> despeckledContours = new ArrayList<>();
+
+    public SpeckleRejectPipe(double minPercentOfAvg) {
+        this.minPercentOfAvg = minPercentOfAvg;
+    }
+
+    public void setConfig(double minPercentOfAvg) {
+        this.minPercentOfAvg = minPercentOfAvg;
+    }
+
+    @Override
+    public Pair<List<MatOfPoint>, Long> run(List<MatOfPoint> input) {
+        long processStartNanos = System.nanoTime();
+
+        despeckledContours.clear();
+
+        if (input.size() > 0) {
+            double averageArea = 0.0;
+
+            for (MatOfPoint c : input) {
+                averageArea += Imgproc.contourArea(c);
+            }
+
+            averageArea /= input.size();
+
+            double minAllowedArea = minPercentOfAvg / 100.0 * averageArea;
+
+            for (MatOfPoint c : input) {
+                if (Imgproc.contourArea(c) >= minAllowedArea) {
+                    despeckledContours.add(c);
+                }
+            }
+        }
+
+        long processTime = System.nanoTime() - processStartNanos;
+        return Pair.of(despeckledContours, processTime);
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/web/RequestHandler.java

@@ -0,0 +1,60 @@
+package com.chameleonvision.web;
+
+import com.chameleonvision.config.ConfigManager;
+import com.chameleonvision.network.NetworkIPMode;
+import com.chameleonvision.vision.VisionManager;
+import com.chameleonvision.vision.VisionProcess;
+import com.chameleonvision.vision.camera.CameraCapture;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.javalin.http.Context;
+
+import java.util.Map;
+
+public class RequestHandler {
+
+    public static void onGeneralSettings(Context ctx) {
+        ObjectMapper objectMapper = new ObjectMapper();
+        try {
+            Map map = objectMapper.readValue(ctx.body(), Map.class);
+
+            // TODO: change to function, to restart NetworkTables
+            ConfigManager.settings.teamNumber = (int) map.get("teamNumber");
+
+            ConfigManager.settings.connectionType = NetworkIPMode.values()[(int) map.get("connectionType")];
+            ConfigManager.settings.ip = (String) map.get("ip");
+            ConfigManager.settings.netmask = (String) map.get("netmask");
+            ConfigManager.settings.gateway = (String) map.get("gateway");
+            ConfigManager.settings.hostname = (String) map.get("hostname");
+            ConfigManager.saveGeneralSettings();
+            SocketHandler.sendFullSettings();
+            ctx.status(200);
+        } catch (JsonProcessingException e) {
+            ctx.status(500);
+        }
+    }
+
+    public static void onCameraSettings(Context ctx) {
+        ObjectMapper objectMapper = new ObjectMapper();
+        try {
+            Map camSettings = objectMapper.readValue(ctx.body(), Map.class);
+
+            VisionProcess currentVisionProcess = VisionManager.getCurrentUIVisionProcess();
+            CameraCapture currentCamera = currentVisionProcess.getCamera();
+
+            double newFOV;
+            try {
+                newFOV = (Double) camSettings.get("fov");
+            } catch (Exception ignored) {
+                newFOV = (Integer) camSettings.get("fov");
+            }
+            currentCamera.getProperties().setFOV(newFOV);
+            VisionManager.saveCurrentCameraSettings();
+            SocketHandler.sendFullSettings();
+            ctx.status(200);
+        } catch (JsonProcessingException e) {
+            e.printStackTrace();
+            ctx.status(500);
+        }
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/web/Server.java

@@ -0,0 +1,35 @@
+package com.chameleonvision.web;
+
+import com.chameleonvision.config.ConfigManager;
+import io.javalin.Javalin;
+
+public class Server {
+    private static SocketHandler socketHandler;
+
+    public static void main(int port) {
+        socketHandler = new SocketHandler();
+
+        Javalin app = Javalin.create(javalinConfig -> {
+            javalinConfig.showJavalinBanner = false;
+            javalinConfig.addStaticFiles("web");
+            javalinConfig.enableCorsForAllOrigins();
+        });
+        app.ws("/websocket", ws -> {
+            ws.onConnect(ctx -> {
+                socketHandler.onConnect(ctx);
+                System.out.println("Socket Connected");
+            });
+            ws.onClose(ctx -> {
+                socketHandler.onClose(ctx);
+                System.out.println("Socket Disconnected");
+                ConfigManager.saveGeneralSettings();
+            });
+            ws.onBinaryMessage(ctx -> {
+                socketHandler.onBinaryMessage(ctx);
+            });
+        });
+        app.post("/api/settings/general", RequestHandler::onGeneralSettings);
+        app.post("/api/settings/camera", RequestHandler::onCameraSettings);
+        app.start(port);
+    }
+}

chameleon-server/src/main/java/com/chameleonvision/web/SocketHandler.java

@@ -0,0 +1,266 @@
+package com.chameleonvision.web;
+
+import com.chameleonvision.config.ConfigManager;
+import com.chameleonvision.vision.VisionManager;
+import com.chameleonvision.vision.VisionProcess;
+import com.chameleonvision.vision.camera.CameraCapture;
+import com.chameleonvision.vision.enums.StreamDivisor;
+import com.chameleonvision.vision.pipeline.CVPipeline;
+import com.chameleonvision.vision.pipeline.CVPipelineSettings;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.javalin.websocket.WsBinaryMessageContext;
+import io.javalin.websocket.WsCloseContext;
+import io.javalin.websocket.WsConnectContext;
+import io.javalin.websocket.WsContext;
+import org.apache.commons.lang3.ArrayUtils;
+import org.msgpack.jackson.dataformat.MessagePackFactory;
+
+import java.lang.reflect.Field;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+
+public class SocketHandler {
+
+    private static List<WsContext> users;
+    private static ObjectMapper objectMapper;
+
+    SocketHandler() {
+        users = new ArrayList<>();
+        objectMapper = new ObjectMapper(new MessagePackFactory());
+    }
+
+    void onConnect(WsConnectContext context) {
+        users.add(context);
+        sendFullSettings();
+    }
+
+    void onClose(WsCloseContext context) {
+        users.remove(context);
+    }
+
+    @SuppressWarnings("unchecked")
+    void onBinaryMessage(WsBinaryMessageContext context) throws Exception {
+        Map<String, Object> deserialized = objectMapper.readValue(ArrayUtils.toPrimitive(context.data()), new TypeReference<>() {
+        });
+        for (Map.Entry<String, Object> entry : deserialized.entrySet()) {
+            try {
+                VisionProcess currentProcess = VisionManager.getCurrentUIVisionProcess();
+                CameraCapture currentCamera = currentProcess.getCamera();
+                CVPipeline currentPipeline = currentProcess.pipelineManager.getCurrentPipeline();
+
+                switch (entry.getKey()) {
+                    case "driverMode": {
+                        HashMap<String, Object> data = (HashMap<String, Object>) entry.getValue();
+                        currentProcess.getDriverModeSettings().exposure = (Integer) data.get("driverExposure");
+                        currentProcess.getDriverModeSettings().brightness = (Integer) data.get("driverBrightness");
+                        currentProcess.setDriverMode((Boolean) data.get("isDriver"));
+
+                        VisionManager.saveCurrentCameraDriverMode();
+                        break;
+                    }
+                    case "changeCameraName": {
+                        currentProcess.setCameraNickname((String) entry.getValue());
+                        sendFullSettings();
+                        VisionManager.saveCurrentCameraSettings();
+                        break;
+                    }
+                    case "changePipelineName": {
+                        currentProcess.pipelineManager.renameCurrentPipeline((String) entry.getValue());
+                        sendFullSettings();
+                        VisionManager.saveCurrentCameraPipelines();
+                        break;
+                    }
+                    case "duplicatePipeline": {
+                        HashMap pipelineVals = (HashMap) entry.getValue();
+                        int pipelineIndex = (int) pipelineVals.get("pipeline");
+                        int cameraIndex = (int) pipelineVals.get("camera");
+                        ObjectMapper mapper = new ObjectMapper();
+                        CVPipelineSettings origPipeline = currentProcess.pipelineManager.getPipeline(pipelineIndex).settings;
+                        String val = mapper.writeValueAsString(origPipeline);
+                        CVPipelineSettings newPipeline = mapper.readValue(val, origPipeline.getClass());
+
+                        if (cameraIndex != -1) {
+                            VisionProcess newProcess = VisionManager.getVisionProcessByIndex(cameraIndex);
+                            if (newProcess != null) {
+                                currentProcess.pipelineManager.duplicatePipeline(newPipeline, newProcess);
+                            } else {
+                                System.err.println("Failed to get destination camera for pipeline duplication!");
+                            }
+                        } else {
+                            currentProcess.pipelineManager.duplicatePipeline(newPipeline);
+                        }
+
+                        VisionManager.saveCurrentCameraPipelines();
+                        sendFullSettings();
+                        break;
+                    }
+                    case "command": {
+                        switch ((String) entry.getValue()) {
+                            case "addNewPipeline":
+                                // TODO: add to UI selection for new 2d/3d
+                                boolean is3d = false;
+                                currentProcess.pipelineManager.addNewPipeline(is3d);
+                                sendFullSettings();
+                                VisionManager.saveCurrentCameraPipelines();
+                                break;
+                            case "deleteCurrentPipeline":
+                                currentProcess.pipelineManager.deleteCurrentPipeline();
+                                sendFullSettings();
+                                VisionManager.saveCurrentCameraPipelines();
+                                break;
+                            case "save":
+                                ConfigManager.saveGeneralSettings();
+                                VisionManager.saveAllCameras();
+                                System.out.println("Saved Settings");
+                                break;
+                        }
+                        // used to define all incoming commands
+                        break;
+                    }
+                    case "currentCamera": {
+                        VisionManager.setCurrentProcessByIndex((Integer) entry.getValue());
+                        sendFullSettings();
+                        break;
+                    }
+                    case "currentPipeline": {
+                        currentProcess.pipelineManager.setCurrentPipeline((Integer) entry.getValue());
+                        sendFullSettings();
+                        break;
+                    }
+                    default: {
+
+                        // only change settings when we aren't in driver mode
+                        if(currentProcess.pipelineManager.getDriverMode()) {
+                            setField(currentProcess.pipelineManager.driverModePipeline.settings, entry.getKey(), entry.getValue());
+                        } else {
+                            setField(currentPipeline.settings, entry.getKey(), entry.getValue());
+                        }
+
+                        switch (entry.getKey()) {
+                            case "exposure": {
+                                currentCamera.setExposure((Integer) entry.getValue());
+                                break;
+                            }
+                            case "brightness": {
+                                currentCamera.setBrightness((Integer) entry.getValue());
+                                break;
+                            }
+                            case "videoModeIndex":{
+                                currentCamera.setVideoMode((Integer) entry.getValue());
+                                break;
+                            }
+                            case "streamDivisor":{
+                                currentProcess.cameraStreamer.setDivisor(StreamDivisor.values()[(Integer) entry.getValue()], true);
+                                break;
+                            }
+                        }
+
+                        VisionManager.saveCurrentCameraPipelines();
+                        break;
+                    }
+                }
+            } catch (Exception e) {
+                System.err.println(e.getMessage());
+            }
+            broadcastMessage(deserialized, context);
+        }
+    }
+
+    private void setField(Object obj, String fieldName, Object value) {
+        try {
+            Field field = obj.getClass().getField(fieldName);
+            if (field.getType().isEnum())
+                field.set(obj, field.getType().getEnumConstants()[(Integer) value]);
+            else
+                field.set(obj, value);
+        } catch (NoSuchFieldException | IllegalAccessException ex) {
+            ex.printStackTrace();
+        }
+    }
+
+    private static void broadcastMessage(Object obj, WsContext userToSkip) {
+        if (users != null)
+            for (WsContext user : users) {
+                if (userToSkip != null && user.getSessionId().equals(userToSkip.getSessionId())) {
+                    continue;
+                }
+                try {
+                    ByteBuffer b = ByteBuffer.wrap(objectMapper.writeValueAsBytes(obj));
+                    user.send(b);
+                } catch (JsonProcessingException e) {
+                    e.printStackTrace();
+                }
+            }
+    }
+
+    public static void broadcastMessage(Object obj) {
+        broadcastMessage(obj, null);//Broadcasts the message to every user
+    }
+
+    private static HashMap<String, Object> getOrdinalPipeline(Class cvClass) throws IllegalAccessException {
+        HashMap<String, Object> tmp = new HashMap<>();
+        for (Field field : cvClass.getFields()) { // iterate over every field in CVPipelineSettings
+            try {
+                if (!field.getType().isEnum()) { // if the field is not an enum, get it based on the current pipeline
+                    tmp.put(field.getName(), field.get(VisionManager.getCurrentUIVisionProcess().pipelineManager.getCurrentPipeline().settings));
+                } else {
+                    var ordinal = (Enum) field.get(VisionManager.getCurrentUIVisionProcess().pipelineManager.getCurrentPipeline().settings);
+                    tmp.put(field.getName(), ordinal.ordinal());
+                }
+            } catch (IllegalArgumentException e) {
+                e.printStackTrace();
+            }
+        }
+        return tmp;
+    }
+
+    private static HashMap<String, Object> getOrdinalSettings() {
+        HashMap<String, Object> tmp = new HashMap<>();
+        tmp.put("teamNumber", ConfigManager.settings.teamNumber);
+        tmp.put("connectionType", ConfigManager.settings.connectionType.ordinal());
+        tmp.put("ip", ConfigManager.settings.ip);
+        tmp.put("gateway", ConfigManager.settings.gateway);
+        tmp.put("netmask", ConfigManager.settings.netmask);
+        tmp.put("hostname", ConfigManager.settings.hostname);
+        return tmp;
+    }
+
+    private static HashMap<String, Object> getOrdinalCameraSettings() {
+        HashMap<String, Object> tmp = new HashMap<>();
+        VisionProcess currentVisionProcess = VisionManager.getCurrentUIVisionProcess();
+        CameraCapture currentCamera = VisionManager.getCurrentUIVisionProcess().getCamera();
+        tmp.put("fov", currentCamera.getProperties().getFOV());
+        tmp.put("streamDivisor", currentVisionProcess.cameraStreamer.getDivisor().ordinal());
+        tmp.put("resolution", currentVisionProcess.getCamera().getProperties().getCurrentVideoModeIndex());
+        return tmp;
+    }
+
+    public static void sendFullSettings() {
+        //General settings
+        Map<String, Object> fullSettings = new HashMap<>();
+
+        VisionProcess currentProcess = VisionManager.getCurrentUIVisionProcess();
+        CVPipeline currentPipeline = currentProcess.pipelineManager.getCurrentPipeline();
+
+        try {
+            fullSettings.put("settings", getOrdinalSettings());
+            fullSettings.put("cameraSettings", getOrdinalCameraSettings());
+            fullSettings.put("cameraList", VisionManager.getAllCameraNicknames());
+            fullSettings.put("pipeline", getOrdinalPipeline(currentPipeline.settings.getClass()));
+            fullSettings.put("pipelineList", VisionManager.getCurrentCameraPipelineNicknames());
+            fullSettings.put("resolutionList", VisionManager.getCurrentCameraResolutionList());
+            fullSettings.put("port", currentProcess.cameraStreamer.getStreamPort());
+            fullSettings.put("currentPipelineIndex", VisionManager.getCurrentUIVisionProcess().pipelineManager.getCurrentPipelineIndex());
+            fullSettings.put("currentCameraIndex", VisionManager.getCurrentUIVisionProcessIndex());
+        } catch (IllegalAccessException e) {
+            System.err.println("No camera found!");
+        }
+        broadcastMessage(fullSettings);
+    }
+}

chameleon-server/src/main/resources/META-INF/MANIFEST.MF

@@ -0,0 +1,2 @@
+Manifest-Version: 1.0
+Main-Class: com.chameleonvision.Main

chameleon-server/src/main/resources/web/Roboto.css

@@ -0,0 +1,336 @@
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 100;
+  src: local('Roboto Thin'), local('Roboto-Thin'), url(https://fonts.gstatic.com/s/roboto/v20/KFOkCnqEu92Fr1MmgVxFIzIFKw.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C88, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 100;
+  src: local('Roboto Thin'), local('Roboto-Thin'), url(https://fonts.gstatic.com/s/roboto/v20/KFOkCnqEu92Fr1MmgVxMIzIFKw.woff2) format('woff2');
+  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 100;
+  src: local('Roboto Thin'), local('Roboto-Thin'), url(https://fonts.gstatic.com/s/roboto/v20/KFOkCnqEu92Fr1MmgVxEIzIFKw.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 100;
+  src: local('Roboto Thin'), local('Roboto-Thin'), url(https://fonts.gstatic.com/s/roboto/v20/KFOkCnqEu92Fr1MmgVxLIzIFKw.woff2) format('woff2');
+  unicode-range: U+0370-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 100;
+  src: local('Roboto Thin'), local('Roboto-Thin'), url(https://fonts.gstatic.com/s/roboto/v20/KFOkCnqEu92Fr1MmgVxHIzIFKw.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 100;
+  src: local('Roboto Thin'), local('Roboto-Thin'), url(https://fonts.gstatic.com/s/roboto/v20/KFOkCnqEu92Fr1MmgVxGIzIFKw.woff2) format('woff2');
+  unicode-range: U+0100-024F, U+0259, U+1E00-1EFF, U+2020, U+20A0-20AB, U+20AD-20CF, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 100;
+  src: local('Roboto Thin'), local('Roboto-Thin'), url(https://fonts.gstatic.com/s/roboto/v20/KFOkCnqEu92Fr1MmgVxIIzI.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 300;
+  src: local('Roboto Light'), local('Roboto-Light'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmSU5fCRc4EsA.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C88, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 300;
+  src: local('Roboto Light'), local('Roboto-Light'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmSU5fABc4EsA.woff2) format('woff2');
+  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 300;
+  src: local('Roboto Light'), local('Roboto-Light'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmSU5fCBc4EsA.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 300;
+  src: local('Roboto Light'), local('Roboto-Light'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmSU5fBxc4EsA.woff2) format('woff2');
+  unicode-range: U+0370-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 300;
+  src: local('Roboto Light'), local('Roboto-Light'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmSU5fCxc4EsA.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 300;
+  src: local('Roboto Light'), local('Roboto-Light'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmSU5fChc4EsA.woff2) format('woff2');
+  unicode-range: U+0100-024F, U+0259, U+1E00-1EFF, U+2020, U+20A0-20AB, U+20AD-20CF, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 300;
+  src: local('Roboto Light'), local('Roboto-Light'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmSU5fBBc4.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 400;
+  src: local('Roboto'), local('Roboto-Regular'), url(https://fonts.gstatic.com/s/roboto/v20/KFOmCnqEu92Fr1Mu72xKOzY.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C88, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 400;
+  src: local('Roboto'), local('Roboto-Regular'), url(https://fonts.gstatic.com/s/roboto/v20/KFOmCnqEu92Fr1Mu5mxKOzY.woff2) format('woff2');
+  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 400;
+  src: local('Roboto'), local('Roboto-Regular'), url(https://fonts.gstatic.com/s/roboto/v20/KFOmCnqEu92Fr1Mu7mxKOzY.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 400;
+  src: local('Roboto'), local('Roboto-Regular'), url(https://fonts.gstatic.com/s/roboto/v20/KFOmCnqEu92Fr1Mu4WxKOzY.woff2) format('woff2');
+  unicode-range: U+0370-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 400;
+  src: local('Roboto'), local('Roboto-Regular'), url(https://fonts.gstatic.com/s/roboto/v20/KFOmCnqEu92Fr1Mu7WxKOzY.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 400;
+  src: local('Roboto'), local('Roboto-Regular'), url(https://fonts.gstatic.com/s/roboto/v20/KFOmCnqEu92Fr1Mu7GxKOzY.woff2) format('woff2');
+  unicode-range: U+0100-024F, U+0259, U+1E00-1EFF, U+2020, U+20A0-20AB, U+20AD-20CF, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 400;
+  src: local('Roboto'), local('Roboto-Regular'), url(https://fonts.gstatic.com/s/roboto/v20/KFOmCnqEu92Fr1Mu4mxK.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 500;
+  src: local('Roboto Medium'), local('Roboto-Medium'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmEU9fCRc4EsA.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C88, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 500;
+  src: local('Roboto Medium'), local('Roboto-Medium'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmEU9fABc4EsA.woff2) format('woff2');
+  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 500;
+  src: local('Roboto Medium'), local('Roboto-Medium'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmEU9fCBc4EsA.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 500;
+  src: local('Roboto Medium'), local('Roboto-Medium'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmEU9fBxc4EsA.woff2) format('woff2');
+  unicode-range: U+0370-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 500;
+  src: local('Roboto Medium'), local('Roboto-Medium'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmEU9fCxc4EsA.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 500;
+  src: local('Roboto Medium'), local('Roboto-Medium'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmEU9fChc4EsA.woff2) format('woff2');
+  unicode-range: U+0100-024F, U+0259, U+1E00-1EFF, U+2020, U+20A0-20AB, U+20AD-20CF, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 500;
+  src: local('Roboto Medium'), local('Roboto-Medium'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmEU9fBBc4.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 700;
+  src: local('Roboto Bold'), local('Roboto-Bold'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmWUlfCRc4EsA.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C88, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 700;
+  src: local('Roboto Bold'), local('Roboto-Bold'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmWUlfABc4EsA.woff2) format('woff2');
+  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 700;
+  src: local('Roboto Bold'), local('Roboto-Bold'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmWUlfCBc4EsA.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 700;
+  src: local('Roboto Bold'), local('Roboto-Bold'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmWUlfBxc4EsA.woff2) format('woff2');
+  unicode-range: U+0370-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 700;
+  src: local('Roboto Bold'), local('Roboto-Bold'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmWUlfCxc4EsA.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 700;
+  src: local('Roboto Bold'), local('Roboto-Bold'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmWUlfChc4EsA.woff2) format('woff2');
+  unicode-range: U+0100-024F, U+0259, U+1E00-1EFF, U+2020, U+20A0-20AB, U+20AD-20CF, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 700;
+  src: local('Roboto Bold'), local('Roboto-Bold'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmWUlfBBc4.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 900;
+  src: local('Roboto Black'), local('Roboto-Black'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmYUtfCRc4EsA.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C88, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 900;
+  src: local('Roboto Black'), local('Roboto-Black'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmYUtfABc4EsA.woff2) format('woff2');
+  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 900;
+  src: local('Roboto Black'), local('Roboto-Black'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmYUtfCBc4EsA.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 900;
+  src: local('Roboto Black'), local('Roboto-Black'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmYUtfBxc4EsA.woff2) format('woff2');
+  unicode-range: U+0370-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 900;
+  src: local('Roboto Black'), local('Roboto-Black'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmYUtfCxc4EsA.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 900;
+  src: local('Roboto Black'), local('Roboto-Black'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmYUtfChc4EsA.woff2) format('woff2');
+  unicode-range: U+0100-024F, U+0259, U+1E00-1EFF, U+2020, U+20A0-20AB, U+20AD-20CF, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Roboto';
+  font-style: normal;
+  font-weight: 900;
+  src: local('Roboto Black'), local('Roboto-Black'), url(https://fonts.gstatic.com/s/roboto/v20/KFOlCnqEu92Fr1MmYUtfBBc4.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}

chameleon-server/src/main/resources/web/css/app.9a11344b.css

@@ -0,0 +1 @@
+html{overflow-y:hidden!important}.imgClass{width:auto;height:45px;vertical-align:middle;padding-right:5px}.tabClass{color:#4baf62}.container{background-color:#212121;padding:0!important}#title{color:#4baf62}span{color:#fff}

chameleon-server/src/main/resources/web/css/chunk-1dc1c444.d7d51460.css

@@ -0,0 +1 @@
+.theme--light.v-radio--is-disabled label{color:rgba(0,0,0,.38)}.theme--light.v-radio--is-disabled .v-icon{color:rgba(0,0,0,.26)!important}.theme--dark.v-radio--is-disabled label{color:hsla(0,0%,100%,.5)}.theme--dark.v-radio--is-disabled .v-icon{color:hsla(0,0%,100%,.3)!important}.v-radio{-webkit-box-align:center;-ms-flex-align:center;align-items:center;display:-webkit-box;display:-ms-flexbox;display:flex;height:auto;margin-right:16px;outline:none}.v-radio--is-disabled{pointer-events:none}.v-input--radio-group__input{display:-webkit-box;display:-ms-flexbox;display:flex;width:100%}.v-input--radio-group--column .v-input--radio-group__input>.v-label{padding-bottom:8px}.v-input--radio-group--row .v-input--radio-group__input>.v-label{padding-right:8px}.v-input--radio-group--row .v-input--radio-group__input{-webkit-box-orient:horizontal;-webkit-box-direction:normal;-ms-flex-direction:row;flex-direction:row;-ms-flex-wrap:wrap;flex-wrap:wrap}.v-input--radio-group--column .v-radio:not(:last-child):not(:only-child){margin-bottom:8px}.v-input--radio-group--column .v-input--radio-group__input{-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;flex-direction:column}.videoClass[data-v-334f1a60]{text-align:center}.videoClass img[data-v-334f1a60]{padding-top:10px;height:auto!important;width:75%;vertical-align:middle}.colsClass[data-v-334f1a60]{padding:0!important}

chameleon-server/src/main/resources/web/css/chunk-a5bde65a.09316a61.css

@@ -0,0 +1 @@
+.theme--light.v-input--range-slider.v-input--slider.v-input--is-disabled .v-slider.v-slider .v-slider__thumb{background:#fafafa}.theme--dark.v-input--range-slider.v-input--slider.v-input--is-disabled .v-slider.v-slider .v-slider__thumb{background:#424242}.v-input--range-slider.v-input--is-disabled .v-slider__track-fill{display:none}.v-input--range-slider.v-input--is-disabled.v-input--slider .v-slider.v-slider .v-slider__thumb{border-color:transparent}

chameleon-server/src/main/resources/web/css/chunk-b88ff188.2fb6e44b.css

@@ -0,0 +1 @@
+.theme--light.v-radio--is-disabled label{color:rgba(0,0,0,.38)}.theme--light.v-radio--is-disabled .v-icon{color:rgba(0,0,0,.26)!important}.theme--dark.v-radio--is-disabled label{color:hsla(0,0%,100%,.5)}.theme--dark.v-radio--is-disabled .v-icon{color:hsla(0,0%,100%,.3)!important}.v-radio{-webkit-box-align:center;-ms-flex-align:center;align-items:center;display:-webkit-box;display:-ms-flexbox;display:flex;height:auto;margin-right:16px;outline:none}.v-radio--is-disabled{pointer-events:none}.v-input--radio-group__input{display:-webkit-box;display:-ms-flexbox;display:flex;width:100%}.v-input--radio-group--column .v-input--radio-group__input>.v-label{padding-bottom:8px}.v-input--radio-group--row .v-input--radio-group__input>.v-label{padding-right:8px}.v-input--radio-group--row .v-input--radio-group__input{-webkit-box-orient:horizontal;-webkit-box-direction:normal;-ms-flex-direction:row;flex-direction:row;-ms-flex-wrap:wrap;flex-wrap:wrap}.v-input--radio-group--column .v-radio:not(:last-child):not(:only-child){margin-bottom:8px}.v-input--radio-group--column .v-input--radio-group__input{-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;flex-direction:column}.videoClass[data-v-0b265c21]{text-align:center}.videoClass img[data-v-0b265c21]{padding-top:10px;height:auto!important;width:75%;vertical-align:middle}.colsClass[data-v-0b265c21]{padding:0!important}

chameleon-server/src/main/resources/web/index.html

@@ -0,0 +1 @@
+<!DOCTYPE html><html lang=en><head><meta charset=utf-8><meta http-equiv=X-UA-Compatible content="IE=edge"><meta name=viewport content="width=device-width,initial-scale=1"><link rel=icon href=/favicon.png><title>Chameleon Vision</title><link rel=stylesheet href=/Roboto.css><link href=/css/chunk-234aed0c.5856ebfe.css rel=prefetch><link href=/css/chunk-37b1319c.6907c2af.css rel=prefetch><link href=/css/chunk-402ab08c.d47fe89d.css rel=prefetch><link href=/css/chunk-5d00d1c8.199ed0d3.css rel=prefetch><link href=/css/chunk-69fdce18.52ef46aa.css rel=prefetch><link href=/css/chunk-716fb61c.78b3d049.css rel=prefetch><link href=/css/chunk-7a810817.e757f52a.css rel=prefetch><link href=/css/chunk-7cf477eb.2ea217a5.css rel=prefetch><link href=/css/chunk-8bc075b4.52ef46aa.css rel=prefetch><link href=/css/chunk-b88ff188.2fb6e44b.css rel=prefetch><link href=/js/chunk-234aed0c.3d3728c3.js rel=prefetch><link href=/js/chunk-37b1319c.2e497e79.js rel=prefetch><link href=/js/chunk-3ae1c3ad.60faee15.js rel=prefetch><link href=/js/chunk-402ab08c.c628d134.js rel=prefetch><link href=/js/chunk-5d00d1c8.ad81a993.js rel=prefetch><link href=/js/chunk-69fdce18.4d1cf405.js rel=prefetch><link href=/js/chunk-716fb61c.84a36d26.js rel=prefetch><link href=/js/chunk-7a810817.baa2981a.js rel=prefetch><link href=/js/chunk-7cf477eb.574926c0.js rel=prefetch><link href=/js/chunk-8bc075b4.6ee7e19a.js rel=prefetch><link href=/js/chunk-98e0c8cc.a1d7ab48.js rel=prefetch><link href=/js/chunk-b88ff188.4fc8cbd4.js rel=prefetch><link href=/css/app.9a11344b.css rel=preload as=style><link href=/css/chunk-vendors.cc4c495b.css rel=preload as=style><link href=/js/app.9a8d90bd.js rel=preload as=script><link href=/js/chunk-vendors.90d5c4b3.js rel=preload as=script><link href=/css/chunk-vendors.cc4c495b.css rel=stylesheet><link href=/css/app.9a11344b.css rel=stylesheet></head><body><noscript><strong>We're sorry but Chameleon Vision doesn't work properly without JavaScript enabled. Please enable it to continue.</strong></noscript><div id=app></div><script src=/js/chunk-vendors.90d5c4b3.js></script><script src=/js/app.9a8d90bd.js></script></body></html>