TAMV.py

#!/usr/bin/env python3

import argparse, logging, os, sys, traceback, time
from logging.handlers import RotatingFileHandler
from urllib.parse import urlparse

# openCV imports
from cv2 import cvtColor, COLOR_BGR2RGB

# Qt imports
from PyQt5.QtCore import Qt, pyqtSlot, pyqtSignal, QSize, QThread, QMutex
from PyQt5.QtGui import QIcon, QPixmap
from PyQt5.QtWidgets import (
    QMainWindow,
    QDesktopWidget,
    QStyle,
    QWidget,
    QMenu,
    QAction,
    QStatusBar,
    QLabel,
    QHBoxLayout,
    QVBoxLayout,
    QTextEdit,
    QPushButton,
    QApplication,
    QTabWidget,
    QButtonGroup,
    QGridLayout,
    QFrame,
    QCheckBox,
)

# Other imports
import json
import numpy as np
import copy
import threading

# Custom modules import
from modules.SettingsDialog import SettingsDialog
from modules.ConnectionDialog import ConnectionDialog
from modules.DetectionManager import DetectionManager
from modules.PrinterManager import PrinterManager
from modules.StatusTipFilter import StatusTipFilter

# import debugpy
# debugpy.debug_this_thread()


########################################################################### Core application class
class App(QMainWindow):
    # Global mutex
    __mutex = QMutex()
    # Signals
    ######## Detection Manager
    startVideoSignal = pyqtSignal()
    setImagePropertiesSignal = pyqtSignal(object)
    getVideoFrameSignal = pyqtSignal()
    # Endstop detection signals
    toggleEndstopDetectionSignal = pyqtSignal(bool)
    toggleEndstopAutoDetectionSignal = pyqtSignal(bool)
    # Nozzle detection signals
    toggleNozzleDetectionSignal = pyqtSignal(bool)
    toggleNozzleAutoDetectionSignal = pyqtSignal(bool)
    # UV coordinates update signal
    getUVCoordinatesSignal = pyqtSignal()
    # Master detection enable/disable signal
    toggleDetectionSignal = pyqtSignal(bool)

    ######## Printer Manager
    connectSignal = pyqtSignal(object)
    disconnectSignal = pyqtSignal(object)
    moveRelativeSignal = pyqtSignal(object)
    moveAbsoluteSignal = pyqtSignal(object)
    callToolSignal = pyqtSignal(int)
    unloadToolSignal = pyqtSignal()
    pollCoordinatesSignal = pyqtSignal()
    pollCurrentToolSignal = pyqtSignal()
    setOffsetsSignal = pyqtSignal(object)
    limitAxesSignal = pyqtSignal()
    flushBufferSignal = pyqtSignal()
    saveToFirmwareSignal = pyqtSignal()
    announceSignal = pyqtSignal(bool)
    # Settings Dialog
    resetImageSignal = pyqtSignal()
    pushbuttonSize = 38
    # default move speed in feedrate/min
    __moveSpeed = 6000
    # Maximum number of retries for detection
    __maxRetries = 3
    # Maximum runtime (in seconds) for calibration cycles
    __maxRuntime = 120
    # Timeout for Qthread termination (DetectionManager and PrinterManager)
    __detectionManagerThreadWaitTime = 20
    __printerManagerThreadWaitTime = 60

    ########################################################################### Initialize class
    def __init__(self, parent=None):
        # send calling to log
        _logger.debug("*** calling App.__init__")

        # output greeting to log
        _logger.info("Initializing application.. ")
        # call QMainWindow init function
        super().__init__()
        #### class attributes definition
        if True:
            # main window size
            self.windowWidthOriginal, self.windowHeightOriginal = 800, 600
            # main camera capture size
            # self.imageWidthOriginal, self.imageHeightOriginal = 640, 480
            # stylesheets used for interface status updates
            self.styleGreen = "* { background-color: green; color: white;} QToolTip { color: black; background-color: #DDDDDD } *:hover{background-color: #003874; color: #ffa000;} *:pressed{background-color: #ffa000; color: #003874;}"
            self.styleRed = "* { background-color: red; color: white;} QToolTip { color: black; background-color: #DDDDDD }"
            self.styleDisabled = "* { background-color: #cccccc; color: #999999; border-style: solid;} QToolTip { color: black; background-color: #DDDDDD }"
            self.styleOrange = "* { background-color: dark-grey; color: #ffa000;} QToolTip { color: black; background-color: #DDDDDD }"
            self.styleBlue = "* { background-color: #003874; color: #ffa000;} QToolTip { color: black; background-color: #DDDDDD }"
            self.styleDefault = "* { background-color: rgba(0,0,0,0); color: black;} QToolTip { color: black; background-color: #DDDDDD }"
            # standby image placeholder
            self.standbyImage = QPixmap("./resources/background.png")
            self.errorImage = QPixmap("./resources/error.png")
            # user-defined cameras array
            self.__cameras = []
            # active camera
            self.__activeCamera = {}
            # user-defined printers array
            self.__printers = []
            # active printer
            self.__activePrinter = {}
            # Control Point
            self.__cpCoordinates = {"X": None, "Y": None, "Z": None}
            self.__currentPosition = {"X": None, "Y": None, "Z": None}
            self.__stateManualCPCapture = False
            self.__stateAutoCPCapture = False
            self.__stateEndstopAutoCalibrate = False
            self.__restorePosition = None
            self.__firstConnection = False
            self.state = 0
            # Camera transform matrix
            self.transformMatrix = None
            self.transform_input = None
            self.mpp = None
            # Nozzle detection
            self.__stateAutoNozzleAlignment = False
            self.__stateOverrideManualNozzleAlignment = False
            self.singleToolOffsetsCapture = False
            self.__displayCrosshair = False

        ####  setup window properties
        if True:
            _logger.debug("  .. setting up window properties..")
            self.setWindowFlag(Qt.WindowContextHelpButtonHint, False)
            self.setWindowTitle("TAMV")
            self.setWindowIcon(QIcon("./resources/jubilee.png"))
            screen = QDesktopWidget().availableGeometry()
            self.setGeometry(
                QStyle.alignedRect(
                    Qt.LeftToRight,
                    Qt.AlignHCenter,
                    QSize(self.windowWidthOriginal, self.windowHeightOriginal),
                    screen,
                )
            )
            self.setMinimumWidth(self.windowWidthOriginal)
            self.setMinimumHeight(self.windowHeightOriginal)
            appScreen = self.frameGeometry()
            appScreen.moveCenter(screen.center())
            self.move(appScreen.topLeft())
            self.centralWidget = QWidget()
            self.setCentralWidget(self.centralWidget)
            #  create stylehseets
            self.globalStylesheet = '\
                QLabel#instructions_text {\
                    background-color: rgba(255,153,0,.4);\
                }\
                QPushButton {\
                    border: 1px solid #adadad;\
                    border-style: outset;\
                    border-radius: 4px;\
                    font: 16px;\
                    padding: 2px;\
                }\
                QPushButton>QToolTip {\
                    color: black;\
                }\
                QPushButton#calibrating:enabled {\
                    background-color: orange;\
                    color: white;\
                }\
                QPushButton#completed:enabled {\
                    background-color: blue;\
                    color: white;\
                }\
                QPushButton:hover,QPushButton:enabled:hover,QPushButton:enabled:!checked:hover,QPushButton#completed:enabled:hover {\
                    background-color: #003874;\
                    color: #ffa000;\
                    border: 1px solid #aaaaaa;\
                }\
                QPushButton:pressed,QPushButton:enabled:pressed,QPushButton:enabled:checked,QPushButton#completed:enabled:pressed {\
                    background-color: #ffa000;\
                    border: 1px solid #aaaaaa;\
                }\
                QPushButton:enabled {\
                    background-color: green;\
                    color: white;\
                }\
                QLabel#labelPlus {\
                    font: 20px;\
                    padding: 0px;\
                }\
                QPushButton#plus:enabled {\
                    font: 20px;\
                    padding: 0px;\
                    background-color: #eeeeee;\
                    color: #000000;\
                }\
                QPushButton#plus:enabled:hover {\
                    font: 20px;\
                    padding: 0px;\
                    background-color: green;\
                    color: #000000;\
                }\
                QPushButton#plus:enabled:pressed {\
                    font: 20px;\
                    padding: 0px;\
                    background-color: #FF0000;\
                    color: #222222;\
                }\
                QPushButton#debug,QMessageBox > #debug {\
                    background-color: blue;\
                    color: white;\
                }\
                QPushButton#debug:hover, QMessageBox > QAbstractButton#debug:hover {\
                    background-color: green;\
                    color: white;\
                }\
                QPushButton#debug:pressed, QMessageBox > QAbstractButton#debug:pressed {\
                    background-color: #ffa000;\
                    border-style: inset;\
                    color: white;\
                }\
                QPushButton#active, QMessageBox > QAbstractButton#active {\
                    background-color: green;\
                    color: white;\
                }\
                QPushButton#active:pressed,QMessageBox > QAbstractButton#active:pressed {\
                    background-color: #ffa000;\
                }\
                QPushButton#terminate {\
                    background-color: red;\
                    color: white;\
                }\
                QPushButton#terminate:pressed {\
                    background-color: #c0392b;\
                }\
                QPushButton:disabled, QPushButton#terminate:disabled {\
                    background-color: #cccccc;\
                    color: #999999;\
                }\
                QInputDialog QDialogButtonBox > QPushButton:enabled, QDialog QPushButton:enabled,QPushButton[checkable="true"]:enabled {\
                    background-color: none;\
                    color: black;\
                    border: 1px solid #adadad;\
                    border-style: outset;\
                    border-radius: 4px;\
                    font: 14px;\
                    padding: 6px;\
                }\
                QPushButton:enabled:checked {\
                    background-color: #ffa000;\
                    border: 1px solid #aaaaaa;\
                }\
                QInputDialog QDialogButtonBox > QPushButton:pressed, QDialog QPushButton:pressed {\
                    background-color: #ffa000;\
                }\
                QInputDialog QDialogButtonBox > QPushButton:hover:!pressed, QDialog QPushButton:hover:!pressed {\
                    background-color: #003874;\
                    color: #ffa000;\
                }\
            QToolTip, QLabel > QToolTip, QPushButton > QLabel> QToolTip {\
                    color: black;\
                }\
                '
            self.setStyleSheet(self.globalStylesheet)
        #### Driver API imports
        if True:
            try:
                self.__firmwareList = []
                self.__driverList = []
                with open("drivers.json", "r") as inputfile:
                    driverJSON = json.load(inputfile)
                _logger.info("  .. loading drivers..")
                for driverEntry in driverJSON:
                    self.__firmwareList.append(driverEntry["firmware"])
                    self.__driverList.append(driverEntry["filename"])
            except:
                _logger.critical(
                    "Cannot load driver definitions: " + traceback.format_exc()
                )
                raise SystemExit("Cannot load driver definitions.")
        #### Setup components
        #  load user parameters
        if True:
            try:
                with open("./config/settings.json", "r") as inputfile:
                    self.__userSettings = json.load(inputfile)
            except FileNotFoundError:
                try:
                    # try and see if moving from older build
                    with open("./settings.json", "r") as inputfile:
                        self.__userSettings = json.load(inputfile)
                    try:
                        _logger.info(
                            "  .. moving settings file to /config/settings.json.. "
                        )
                        # create config folder if it doesn't exist
                        os.makedirs("./config", exist_ok=True)
                        # move settings.json to new config folder
                        os.replace("./settings.json", "./config/settings.json")
                    except:
                        _logger.warning(
                            "Cannot rename old settings.json, leaving in place and using new file."
                        )
                except FileNotFoundError:
                    # create config folder if it doesn't exist
                    os.makedirs("./config", exist_ok=True)
                    # No settings file defined, create a default file
                    _logger.info("  .. creating new settings.json..")
                    self.__userSettings = {}
                    # create a camera array
                    self.__userSettings["camera"] = [
                        {
                            "video_src": 0,
                            "display_width": "640",
                            "display_height": "480",
                            "default": 1,
                        }
                    ]
                    # Create a printer array
                    self.__userSettings["printer"] = [
                        {
                            "address": "http://localhost",
                            "password": "reprap",
                            "name": "My Duet",
                            "nickname": "Default",
                            "controller": "RRF",
                            "version": "",
                            "default": 1,
                            "rotated": 0,
                            "tools": [
                                {
                                    "number": 0,
                                    "name": "Tool 0",
                                    "nozzleSize": 0.4,
                                    "offsets": [0, 0, 0],
                                }
                            ],
                        }
                    ]
                    try:
                        # set class attributes
                        self._cameraWidth = int(
                            self.__userSettings["camera"][0]["display_width"]
                        )
                        self._cameraHeight = int(
                            self.__userSettings["camera"][0]["display_height"]
                        )
                        self._videoSrc = self.__userSettings["camera"][0]["video_src"]
                        # save default settings file
                        with open("./config/settings.json", "w") as outputfile:
                            json.dump(self.__userSettings, outputfile)
                    except Exception as e1:
                        errorMsg = (
                            "Error reading user settings file." + traceback.format_exc()
                        )
                        _logger.critical(errorMsg)
                        raise SystemExit(errorMsg)
            _logger.info("  .. reading configuration settings..")
        # Fetch defined cameras
        if True:
            defaultCameraDefined = False
            for source in self.__userSettings["camera"]:
                try:
                    self.__cameras.append(source)
                    if source["default"] == 1 and defaultCameraDefined is False:
                        self.__activeCamera = source
                        defaultCameraDefined = True
                    elif defaultCameraDefined:
                        source["default"] = 0
                    continue
                except KeyError as ke:
                    source["default"] = 0
                    continue
            if defaultCameraDefined is False:
                self.__userSettings["camera"][0]["default"] = 1
                self.__activeCamera = self.__userSettings["camera"][0]
            self._cameraHeight = int(self.__activeCamera["display_height"])
            self._cameraWidth = int(self.__activeCamera["display_width"])
            self._videoSrc = self.__activeCamera["video_src"]
            if len(str(self._videoSrc)) == 1 or str(self._videoSrc) == "-1":
                self._videoSrc = int(self._videoSrc)
        # Fetch defined machines
        if True:
            defaultPrinterDefined = False
            for machine in self.__userSettings["printer"]:
                # Find default printer first
                try:
                    self.__printers.append(machine)
                    if machine["default"] == 1:
                        self.__activePrinter = machine
                        defaultPrinterDefined = True
                except KeyError as ke:
                    # no default field detected - create a default if not already done
                    if defaultPrinterDefined is False:
                        machine["default"] = 1
                        defaultPrinterDefined = True
                    else:
                        machine["default"] = 0
                # Check if password doesn't exist
                try:
                    temp = machine["password"]
                except KeyError:
                    machine["password"] = "reprap"
                # Check if nickname doesn't exist
                try:
                    temp = machine["nickname"]
                except KeyError:
                    machine["nickname"] = machine["name"]
                # Check if controller doesn't exist
                try:
                    temp = machine["controller"]
                except KeyError:
                    machine["controller"] = "RRF"
                # Check if version doesn't exist
                try:
                    temp = machine["version"]
                except KeyError:
                    machine["version"] = ""
                # Check if rotated kinematics doesn't exist
                try:
                    temp = machine["rotated"]
                except KeyError:
                    machine["rotated"] = 0
                # Check if tools doesn't exist
                try:
                    temp = machine["tools"]
                except KeyError:
                    machine["tools"] = [
                        {
                            "number": 0,
                            "name": "Tool 0",
                            "nozzleSize": 0.4,
                            "offsets": [0, 0, 0],
                        }
                    ]
                if machine["default"] == 1:
                    self.__activePrinter = machine
            # Check if we have no default machine
            if defaultPrinterDefined is False:
                self.__activePrinter = self.__userSettings["printer"][0]
            if self.__activePrinter["controller"] == "RRF":
                (_errCode, _errMsg, self.printerURL) = self.sanitizeURL(
                    self.__activePrinter["address"]
                )
                self.__activePrinter["address"] = self.printerURL
                if _errCode > 0:
                    # invalid input
                    _logger.error("Invalid printer URL detected in settings.json")
                    _logger.error(_errMsg)
                    _logger.info('Defaulting to "http://localhost"...')
                    self.printerURL = "http://localhost"

        ##### Settings Dialog
        self.__settingsGeometry = None
        # Note: settings dialog is created when user clicks the button

        #### Setup interface
        ##### Menu bar
        self.setupMenu()
        ##### Status bar
        self.setupStatusbar()
        ##### GUI elements
        self.setupMainWindow()

        # send exiting to log
        _logger.debug("*** exiting App.__init__")

    ########################################################################### Menu setup
    def setupMenu(self):
        # send calling to log
        _logger.debug("*** calling App.setupMenu")

        self.menubar = self.menuBar()
        self.menubar.installEventFilter(StatusTipFilter(self))
        #### File menu
        fileMenu = QMenu("&File", self)
        self.menubar.addMenu(fileMenu)
        #### Preferences
        self.preferencesAction = QAction(self)
        self.preferencesAction.setText("&Preferences..")
        self.preferencesAction.triggered.connect(self.displayPreferences)
        fileMenu.addAction(self.preferencesAction)
        #### Save offsets to firmware
        self.saveFirmwareAction = QAction(self)
        self.saveFirmwareAction.setText("&Save offsets..")
        self.saveFirmwareAction.triggered.connect(self.saveOffsets)
        fileMenu.addAction(self.saveFirmwareAction)
        # Quit
        self.quitAction = QAction(self)
        self.quitAction.setText("&Quit")
        self.quitAction.triggered.connect(self.close)
        fileMenu.addSeparator()
        fileMenu.addAction(self.quitAction)

        # send exiting to log
        _logger.debug("*** exiting App.setupMenu")

    ########################################################################### Status bar setup
    def setupStatusbar(self):
        # send calling to log
        _logger.debug("*** calling App.setupStatusbar")

        self.statusBar = QStatusBar()
        self.statusBar.showMessage("Welcome.")
        self.setStatusBar(self.statusBar)
        #### CP coodinate status
        self.cpLabel = QLabel("<b>CP:</b> <i>undef</i>")
        self.statusBar.addPermanentWidget(self.cpLabel)
        self.cpLabel.setStyleSheet(self.styleOrange)

        #### Connection status
        self.connectionStatusLabel = QLabel("<i>Disconnected</i>")
        self.connectionStatusLabel.setStyleSheet(self.styleOrange)
        self.statusBar.addPermanentWidget(self.connectionStatusLabel)

        # send exiting to log
        _logger.debug("*** exiting App.setupStatusbar")

    ########################################################################### Main window setup
    def setupMainWindow(self):
        # send calling to log
        _logger.debug("*** calling App.setupMenu")

        self.containerLayout = QVBoxLayout()
        self.containerLayout.setSpacing(8)
        self.centralWidget.setLayout(self.containerLayout)
        #### Main grid layout
        if True:
            self.mainLayout = QHBoxLayout()
            self.mainLayout.setSpacing(8)
            self.containerLayout.addLayout(self.mainLayout)
            ##### Left toolbar
            if True:
                self.leftToolbarLayout = QVBoxLayout()
                self.leftToolbarLayout.setAlignment(Qt.AlignTop)
                self.mainLayout.addLayout(self.leftToolbarLayout)
                # Connect button
                self.connectButton = QPushButton("+")
                self.connectButton.setStyleSheet(self.styleDisabled)
                self.connectButton.setMinimumSize(
                    self.pushbuttonSize, self.pushbuttonSize
                )
                self.connectButton.setMaximumSize(
                    self.pushbuttonSize, self.pushbuttonSize
                )
                self.connectButton.setToolTip("Connect..")
                self.connectButton.setDisabled(True)
                self.connectButton.clicked.connect(self.connectPrinter)
                self.leftToolbarLayout.addWidget(
                    self.connectButton
                )  # , 1, 0, 1, 1, Qt.AlignLeft|Qt.AlignTop)
                # Disconnect button
                self.disconnectButton = QPushButton("D")
                self.disconnectButton.setStyleSheet(self.styleDisabled)
                self.disconnectButton.setMinimumSize(
                    self.pushbuttonSize, self.pushbuttonSize
                )
                self.disconnectButton.setMaximumSize(
                    self.pushbuttonSize, self.pushbuttonSize
                )
                self.disconnectButton.setToolTip("Disconnect..")
                self.disconnectButton.setDisabled(True)
                self.disconnectButton.clicked.connect(self.haltPrinterOperation)
                self.leftToolbarLayout.addWidget(
                    self.disconnectButton
                )  # , 1, 0, 1, 1, Qt.AlignLeft|Qt.AlignTop)
                # Crosshair button
                self.crosshairDisplayButton = QPushButton("-+-")
                self.crosshairDisplayButton.setStyleSheet(self.styleBlue)
                self.crosshairDisplayButton.setMinimumSize(
                    self.pushbuttonSize, self.pushbuttonSize
                )
                self.crosshairDisplayButton.setMaximumSize(
                    self.pushbuttonSize, self.pushbuttonSize
                )
                self.crosshairDisplayButton.setToolTip("toggle crosshair on display")
                self.crosshairDisplayButton.setDisabled(False)
                self.crosshairDisplayButton.setChecked(False)
                self.crosshairDisplayButton.clicked.connect(self.toggleCrosshair)
                self.leftToolbarLayout.addWidget(self.crosshairDisplayButton)
                # Setup Control Point button
                self.cpSetupButton = QPushButton("CP")
                self.cpSetupButton.setStyleSheet(self.styleDisabled)
                self.cpSetupButton.setMinimumSize(
                    self.pushbuttonSize, self.pushbuttonSize
                )
                self.cpSetupButton.setMaximumSize(
                    self.pushbuttonSize, self.pushbuttonSize
                )
                self.cpSetupButton.setToolTip("Setup Control Point..")
                self.cpSetupButton.setDisabled(True)
                self.cpSetupButton.clicked.connect(self.setupCPCapture)
                self.leftToolbarLayout.addWidget(self.cpSetupButton)
                # CP Automated Capture button
                self.cpAutoCaptureButton = QPushButton("Auto")
                self.cpAutoCaptureButton.setStyleSheet(self.styleDisabled)
                self.cpAutoCaptureButton.setMinimumSize(
                    self.pushbuttonSize, self.pushbuttonSize
                )
                self.cpAutoCaptureButton.setMaximumSize(
                    self.pushbuttonSize, self.pushbuttonSize
                )
                self.cpAutoCaptureButton.setToolTip("Automated CP Capture..")
                self.cpAutoCaptureButton.setDisabled(True)
                self.cpAutoCaptureButton.clicked.connect(self.setupCPAutoCapture)
                self.leftToolbarLayout.addWidget(self.cpAutoCaptureButton)

            ##### Main image preview
            if True:
                self.image = QLabel(self)
                self.image.resize(self._cameraWidth, self._cameraHeight)
                self.image.setMinimumWidth(self._cameraWidth)
                self.image.setMinimumHeight(self._cameraHeight)
                self.image.setAlignment(Qt.AlignLeft)
                # self.image.setStyleSheet('text-align:center; border: 1px solid black')
                self.image.setPixmap(self.standbyImage)
                self.mainLayout.addWidget(
                    self.image
                )  # , 1, 1, 1, -1, Qt.AlignLeft|Qt.AlignTop)

            ##### Right toolbar
            if True:
                # Jog Panel
                self.tabPanel = QTabWidget()
                self.firstTab = QWidget()
                self.jogPanel = QGridLayout()
                self.jogPanel.setAlignment(Qt.AlignRight | Qt.AlignTop)
                self.jogPanel.setSpacing(5)

                # create jogPanel buttons
                ## increment size
                self.button_1 = QPushButton("1")
                self.button_1.setFixedSize(self.pushbuttonSize, self.pushbuttonSize)
                self.button_1.setMaximumHeight(self.pushbuttonSize)
                self.button_1.setToolTip("set jog distance to 1 unit")
                self.button_01 = QPushButton(".1")
                self.button_01.setFixedSize(self.pushbuttonSize, self.pushbuttonSize)
                self.button_01.setMaximumHeight(self.pushbuttonSize)
                self.button_01.setToolTip("set jog distance to 0.1 unit")
                self.button_001 = QPushButton(".01")
                self.button_001.setFixedSize(self.pushbuttonSize, self.pushbuttonSize)
                self.button_001.setMaximumHeight(self.pushbuttonSize)
                self.button_001.setToolTip("set jog distance to 0.01 unit")
                self.incrementButtonGroup = QButtonGroup()
                self.incrementButtonGroup.addButton(self.button_1)
                self.incrementButtonGroup.addButton(self.button_01)
                self.incrementButtonGroup.addButton(self.button_001)
                self.incrementButtonGroup.setExclusive(True)
                self.button_1.setCheckable(True)
                self.button_01.setCheckable(True)
                self.button_001.setCheckable(True)
                self.button_1.setChecked(True)

                # horizontal separators
                self.incrementLine = QFrame()
                self.incrementLine.setFrameShape(QFrame.HLine)
                self.incrementLine.setLineWidth(1)
                self.incrementLine.setFrameShadow(QFrame.Sunken)
                self.keypadLine = QFrame()
                self.keypadLine.setFrameShape(QFrame.HLine)
                self.keypadLine.setFrameShadow(QFrame.Sunken)
                self.keypadLine.setLineWidth(1)

                ## X movement
                self.button_x_left = QPushButton("-X", objectName="plus")
                self.button_x_left.setFixedSize(
                    self.pushbuttonSize, self.pushbuttonSize
                )
                self.button_x_left.setMaximumHeight(self.pushbuttonSize)
                self.button_x_left.setToolTip("jog X-")
                self.button_x_left.clicked.connect(self.xleftClicked)
                self.button_x_right = QPushButton("X+", objectName="plus")
                self.button_x_right.setFixedSize(
                    self.pushbuttonSize, self.pushbuttonSize
                )
                self.button_x_right.setMaximumHeight(self.pushbuttonSize)
                self.button_x_right.setToolTip("jog X+")
                self.button_x_right.clicked.connect(self.xRightClicked)

                ## Y movement
                self.button_y_left = QPushButton("-Y", objectName="plus")
                self.button_y_left.setFixedSize(
                    self.pushbuttonSize, self.pushbuttonSize
                )
                self.button_y_left.setMaximumHeight(self.pushbuttonSize)
                self.button_y_left.setToolTip("jog Y-")
                self.button_y_left.clicked.connect(self.yleftClicked)
                self.button_y_right = QPushButton("Y+", objectName="plus")
                self.button_y_right.setFixedSize(
                    self.pushbuttonSize, self.pushbuttonSize
                )
                self.button_y_right.setMaximumHeight(self.pushbuttonSize)
                self.button_y_right.setToolTip("jog Y+")
                self.button_y_right.clicked.connect(self.yRightClicked)

                ## Z movement
                self.button_z_down = QPushButton("-Z", objectName="plus")
                self.button_z_down.setFixedSize(
                    self.pushbuttonSize, self.pushbuttonSize
                )
                self.button_z_down.setMaximumHeight(self.pushbuttonSize)
                self.button_z_down.setToolTip("jog Z-")
                self.button_z_down.clicked.connect(self.zleftClicked)
                self.button_z_up = QPushButton("Z+", objectName="plus")
                self.button_z_up.setFixedSize(self.pushbuttonSize, self.pushbuttonSize)
                self.button_z_up.setMaximumHeight(self.pushbuttonSize)
                self.button_z_up.setToolTip("jog Z+")
                self.button_z_up.clicked.connect(self.zRightClicked)

                ## layout jogPanel buttons
                # add increment buttons
                self.jogPanel.addWidget(self.button_001, 0, 0)
                self.jogPanel.addWidget(self.button_01, 0, 1)
                self.jogPanel.addWidget(self.button_1, 1, 1)
                # add separator
                self.jogPanel.addWidget(self.incrementLine, 2, 0, 1, 2)
                # add X movement buttons
                self.jogPanel.addWidget(self.button_x_left, 3, 0)
                self.jogPanel.addWidget(self.button_x_right, 3, 1)
                # add Y movement buttons
                self.jogPanel.addWidget(self.button_y_left, 4, 0)
                self.jogPanel.addWidget(self.button_y_right, 4, 1)
                # add Z movement buttons
                self.jogPanel.addWidget(self.button_z_down, 5, 0)
                self.jogPanel.addWidget(self.button_z_up, 5, 1)
                # add separator
                self.jogPanel.addWidget(self.keypadLine, 6, 0, 1, 2)

                self.tabPanel.setDisabled(True)
                self.mainLayout.addWidget(self.tabPanel)
                self.firstTab.setLayout(self.jogPanel)
                self.tabPanel.addTab(self.firstTab, "Jog")
                self.tabPanel.setFixedWidth(95)
                self.tabPanel.setTabBarAutoHide(True)
                self.tabPanel.setStyleSheet(
                    "QTabWidget::pane {\
                    margin: -13px -9px -13px -9px;\
                    border: 1px solid white;\
                    padding: 0px;\
                    }"
                )

        #### Footer layout
        if True:
            self.footerLayout = QGridLayout()
            self.footerLayout.setSpacing(0)
            self.containerLayout.addLayout(self.footerLayout)
            # Intructions box
            self.instructionsBox = QTextEdit()
            self.instructionsBox.setReadOnly(True)
            self.instructionsBox.setFixedSize(640, 45)
            self.instructionsBox.setVisible(False)
            self.footerLayout.addWidget(
                self.instructionsBox, 0, 0, 1, -1, Qt.AlignLeft | Qt.AlignVCenter
            )

            # Manual CP Capture button
            self.manualCPCaptureButton = QPushButton("Save CP")
            self.manualCPCaptureButton.setStyleSheet(self.styleDisabled)
            self.manualCPCaptureButton.setMinimumSize(
                self.pushbuttonSize * 2, self.pushbuttonSize
            )
            self.manualCPCaptureButton.setMaximumSize(
                self.pushbuttonSize * 2, self.pushbuttonSize
            )
            self.manualCPCaptureButton.setToolTip(
                "Capture current machine coordinates as the Control Point."
            )
            self.manualCPCaptureButton.setDisabled(True)
            self.manualCPCaptureButton.setVisible(False)
            self.manualCPCaptureButton.clicked.connect(self.manualCPCapture)
            self.footerLayout.addWidget(
                self.manualCPCaptureButton, 0, 1, 1, 1, Qt.AlignRight | Qt.AlignVCenter
            )

            # Override Manual Tool offset Capture button
            self.overrideManualOffsetCaptureButton = QPushButton("Capture offset")
            self.overrideManualOffsetCaptureButton.setStyleSheet(self.styleDisabled)
            self.overrideManualOffsetCaptureButton.setMinimumSize(
                self.pushbuttonSize * 3, self.pushbuttonSize
            )
            self.overrideManualOffsetCaptureButton.setMaximumSize(
                self.pushbuttonSize * 3, self.pushbuttonSize
            )
            self.overrideManualOffsetCaptureButton.setToolTip(
                "Capture current position and calculate tool offset."
            )
            self.overrideManualOffsetCaptureButton.setDisabled(True)
            self.overrideManualOffsetCaptureButton.setVisible(False)
            self.overrideManualOffsetCaptureButton.clicked.connect(
                self.overrideManualToolOffsetCapture
            )
            self.footerLayout.addWidget(
                self.overrideManualOffsetCaptureButton,
                0,
                1,
                1,
                1,
                Qt.AlignRight | Qt.AlignVCenter,
            )

            # Manual Tool offset Capture button
            self.manualToolOffsetCaptureButton = QPushButton("Capture offset")
            self.manualToolOffsetCaptureButton.setStyleSheet(self.styleDisabled)
            self.manualToolOffsetCaptureButton.setMinimumSize(
                self.pushbuttonSize * 3, self.pushbuttonSize
            )
            self.manualToolOffsetCaptureButton.setMaximumSize(
                self.pushbuttonSize * 3, self.pushbuttonSize
            )
            self.manualToolOffsetCaptureButton.setToolTip(
                "Capture current position and calculate tool offset."
            )
            self.manualToolOffsetCaptureButton.setDisabled(True)
            self.manualToolOffsetCaptureButton.setVisible(False)
            self.manualToolOffsetCaptureButton.clicked.connect(
                self.manualToolOffsetCapture
            )
            self.footerLayout.addWidget(
                self.manualToolOffsetCaptureButton,
                0,
                0,
                1,
                1,
                Qt.AlignRight | Qt.AlignVCenter,
            )

            # Start Alignment button
            self.startAlignToolsButton = QPushButton("Align Tools")
            self.startAlignToolsButton.setStyleSheet(self.styleDisabled)
            self.startAlignToolsButton.setMinimumSize(
                self.pushbuttonSize * 3, self.pushbuttonSize
            )
            self.startAlignToolsButton.setMaximumSize(
                self.pushbuttonSize * 3, self.pushbuttonSize
            )
            self.startAlignToolsButton.setToolTip(
                "Start automated tool offset calibration"
            )
            self.startAlignToolsButton.setDisabled(True)
            self.startAlignToolsButton.setVisible(False)
            self.startAlignToolsButton.clicked.connect(self.startAlignTools)
            self.footerLayout.addWidget(
                self.startAlignToolsButton, 0, 1, 1, 1, Qt.AlignRight | Qt.AlignVCenter
            )

            # Resume auto alignment button
            self.resumeAutoToolAlignmentButton = QPushButton("Resume Auto Align")
            self.resumeAutoToolAlignmentButton.setMinimumSize(
                self.pushbuttonSize * 4, self.pushbuttonSize
            )
            self.resumeAutoToolAlignmentButton.setMaximumSize(
                self.pushbuttonSize * 4, self.pushbuttonSize
            )
            self.resumeAutoToolAlignmentButton.setToolTip(
                "Resume automated calibration"
            )
            self.resumeAutoToolAlignmentButton.setDisabled(True)
            self.resumeAutoToolAlignmentButton.setVisible(False)
            self.resumeAutoToolAlignmentButton.clicked.connect(self.resumeAutoAlignment)
            self.footerLayout.addWidget(
                self.resumeAutoToolAlignmentButton,
                0,
                0,
                1,
                1,
                Qt.AlignRight | Qt.AlignVCenter,
            )

        #### Set current interface state to disconnected
        self.stateDisconnected()

        # send exiting to log
        _logger.debug("*** exiting App.setupMenu")

    ########################################################################### Jog Panel functions
    def xleftClicked(self):
        # disable buttons
        self.tabPanel.setDisabled(True)
        # fetch current increment value
        if self.button_1.isChecked():
            incrementDistance = 1
        elif self.button_01.isChecked():
            incrementDistance = 0.1
        elif self.button_001.isChecked():
            incrementDistance = 0.01
        params = {
            "moveSpeed": self.__moveSpeed,
            "position": {"X": str(-1 * incrementDistance)},
        }
        self.moveRelativeSignal.emit(params)

    def xRightClicked(self):
        # disable buttons
        self.tabPanel.setDisabled(True)
        # fetch current increment value
        if self.button_1.isChecked():
            incrementDistance = 1
        elif self.button_01.isChecked():
            incrementDistance = 0.1
        elif self.button_001.isChecked():
            incrementDistance = 0.01
        params = {
            "moveSpeed": self.__moveSpeed,
            "position": {"X": str(incrementDistance)},
        }
        self.moveRelativeSignal.emit(params)

    def yleftClicked(self):
        # disable buttons
        self.tabPanel.setDisabled(True)
        # fetch current increment value
        if self.button_1.isChecked():
            incrementDistance = 1
        elif self.button_01.isChecked():
            incrementDistance = 0.1
        elif self.button_001.isChecked():
            incrementDistance = 0.01
        params = {
            "moveSpeed": self.__moveSpeed,
            "position": {"Y": str(-1 * incrementDistance)},
        }
        self.moveRelativeSignal.emit(params)

    def yRightClicked(self):
        # disable buttons
        self.tabPanel.setDisabled(True)
        # fetch current increment value
        if self.button_1.isChecked():
            incrementDistance = 1
        elif self.button_01.isChecked():
            incrementDistance = 0.1
        elif self.button_001.isChecked():
            incrementDistance = 0.01
        params = {
            "moveSpeed": self.__moveSpeed,
            "position": {"Y": str(incrementDistance)},
        }
        self.moveRelativeSignal.emit(params)

    def zleftClicked(self):
        # disable buttons
        self.tabPanel.setDisabled(True)
        # fetch current increment value
        if self.button_1.isChecked():
            incrementDistance = 1
        elif self.button_01.isChecked():
            incrementDistance = 0.1
        elif self.button_001.isChecked():
            incrementDistance = 0.01
        params = {
            "moveSpeed": self.__moveSpeed,
            "position": {"Z": str(-1 * incrementDistance)},
        }
        self.moveRelativeSignal.emit(params)

    def zRightClicked(self):
        # disable buttons
        self.tabPanel.setDisabled(True)
        # fetch current increment value
        if self.button_1.isChecked():
            incrementDistance = 1
        elif self.button_01.isChecked():
            incrementDistance = 0.1
        elif self.button_001.isChecked():
            incrementDistance = 0.01
        params = {
            "moveSpeed": self.__moveSpeed,
            "position": {"Z": str(incrementDistance)},
        }
        self.moveRelativeSignal.emit(params)

    ########################################################################### GUI State functions
    def stateDisconnected(self):
        # Settings option in menu
        self.preferencesAction.setDisabled(False)
        # Connect button
        self.connectButton.setVisible(True)
        self.connectButton.setDisabled(False)
        self.connectButton.setStyleSheet(self.styleGreen)
        # Disconnect button
        self.disconnectButton.setVisible(False)
        self.disconnectButton.setDisabled(True)
        self.disconnectButton.setStyleSheet(self.styleDisabled)
        # Setup CP button
        self.cpSetupButton.setVisible(False)
        self.cpSetupButton.setDisabled(True)
        self.cpSetupButton.setStyleSheet(self.styleDisabled)
        # CP Automated Capture button
        self.cpAutoCaptureButton.setVisible(False)
        self.cpAutoCaptureButton.setDisabled(True)
        self.cpAutoCaptureButton.setStyleSheet(self.styleDisabled)
        # Manual capture button
        self.manualCPCaptureButton.setVisible(False)
        self.manualCPCaptureButton.setDisabled(True)
        self.manualCPCaptureButton.setStyleSheet(self.styleDisabled)
        # Start Alignment button
        self.startAlignToolsButton.setVisible(False)
        self.startAlignToolsButton.setDisabled(True)
        self.startAlignToolsButton.setText("Align Tools")
        self.startAlignToolsButton.setStyleSheet(self.styleDisabled)
        # Override Manual Tool offset Capture button
        self.overrideManualOffsetCaptureButton.setVisible(False)
        self.overrideManualOffsetCaptureButton.setDisabled(True)
        self.overrideManualOffsetCaptureButton.setStyleSheet(self.styleDisabled)
        # Manual Tool offset Capture button
        self.manualToolOffsetCaptureButton.setDisabled(True)
        self.manualToolOffsetCaptureButton.setVisible(False)
        self.manualToolOffsetCaptureButton.setStyleSheet(self.styleDisabled)
        # Resume auto alignment button
        self.resumeAutoToolAlignmentButton.setVisible(False)
        self.resumeAutoToolAlignmentButton.setDisabled(True)
        self.resumeAutoToolAlignmentButton.setStyleSheet(self.styleDisabled)
        # Delete tool buttons
        count = self.jogPanel.count()
        for i in range(11, count):
            item = self.jogPanel.itemAt(i)
            widget = item.widget()
            widget.setVisible(False)
            # widget.deleteLater()
        self.resetCalibration()
        # Crosshair display button
        self.crosshairDisplayButton.setVisible(True)
        self.crosshairDisplayButton.setDisabled(False)
        if self.__displayCrosshair:
            self.crosshairDisplayButton.setStyleSheet(self.styleOrange)
            self.crosshairDisplayButton.setChecked(True)
        else:
            self.crosshairDisplayButton.setStyleSheet(self.styleBlue)
            self.crosshairDisplayButton.setChecked(False)
        # Jog panel tab
        self.tabPanel.setDisabled(True)

    def stateConnected(self):
        # Settings option in menu
        self.preferencesAction.setDisabled(False)
        # Connect button
        self.connectButton.setVisible(False)
        self.connectButton.setDisabled(True)
        self.connectButton.setStyleSheet(self.styleDisabled)
        # Disconnect button
        self.disconnectButton.setVisible(True)
        self.disconnectButton.setDisabled(False)
        self.disconnectButton.setStyleSheet(self.styleRed)
        self.disconnectButton.setText("D")
        self.disconnectButton.setToolTip("Disconnect..")
        # Setup CP button
        self.cpSetupButton.setVisible(True)
        self.cpSetupButton.setDisabled(False)
        self.cpSetupButton.setStyleSheet(self.styleGreen)
        # CP Automated Capture button
        self.cpAutoCaptureButton.setVisible(False)
        self.cpAutoCaptureButton.setDisabled(True)
        self.cpAutoCaptureButton.setStyleSheet(self.styleDisabled)
        # Manual capture button
        self.manualCPCaptureButton.setVisible(False)
        self.manualCPCaptureButton.setDisabled(True)
        self.manualCPCaptureButton.setStyleSheet(self.styleDisabled)
        # Start Alignment button
        self.startAlignToolsButton.setVisible(False)
        self.startAlignToolsButton.setDisabled(True)
        self.startAlignToolsButton.setText("Align Tools")
        self.startAlignToolsButton.setStyleSheet(self.styleDisabled)
        # Override Manual Tool offset Capture button
        self.overrideManualOffsetCaptureButton.setVisible(False)
        self.overrideManualOffsetCaptureButton.setDisabled(True)
        self.overrideManualOffsetCaptureButton.setStyleSheet(self.styleDisabled)
        # Manual Tool offset Capture button
        self.manualToolOffsetCaptureButton.setDisabled(True)
        self.manualToolOffsetCaptureButton.setVisible(False)
        self.manualToolOffsetCaptureButton.setStyleSheet(self.styleDisabled)
        # Resume auto alignment button
        self.resumeAutoToolAlignmentButton.setVisible(False)
        self.resumeAutoToolAlignmentButton.setDisabled(True)
        self.resumeAutoToolAlignmentButton.setStyleSheet(self.styleDisabled)
        # Jog panel tab
        self.tabPanel.setDisabled(False)

        # Add tool checkboxes to right panel
        self.toolButtons = []
        self.toolCheckboxes = []
        # highest tool number storage
        numTools = max(self.__activePrinter["tools"], key=lambda x: int(x["number"]))[
            "number"
        ]
        _logger.debug("Highest tool number is: " + str(numTools))
        # Delete old toolbuttons, if they exist
        # Delete tool buttons
        count = self.jogPanel.count()
        for i in range(11, count):
            item = self.jogPanel.itemAt(i)
            widget = item.widget()
            widget.deleteLater()
        currentTool = 0
        for tool in range(numTools + 1):
            # add tool buttons
            toolButton = QPushButton("T" + str(tool))
            toolButton.setObjectName("toolButton_" + str(tool))
            toolButton.setFixedSize(self.pushbuttonSize, self.pushbuttonSize)
            toolButton.clicked.connect(self.identifyToolButton)
            # check if current index exists in tool numbers from machine
            if any(d.get("number", -1) == tool for d in self.__activePrinter["tools"]):
                toolTip = "Fetch T" + str(tool) + " to current machine position."
                toolTip += "<pre>"
                toolTip += "X: " + "{:>9.3f}".format(
                    self.__activePrinter["tools"][currentTool]["offsets"][0]
                )
                toolTip += "<br>"
                toolTip += "Y: " + "{:>9.3f}".format(
                    self.__activePrinter["tools"][currentTool]["offsets"][1]
                )
                toolTip += "<br>"
                toolTip += "Z: " + "{:>9.3f}".format(
                    self.__activePrinter["tools"][currentTool]["offsets"][2]
                )
                toolTip += "</pre>"
                currentTool += 1
                toolButton.setToolTip(toolTip)
                self.toolButtons.append(toolButton)
                # add tool checkboxes
                toolCheckbox = QCheckBox()
                toolCheckbox.setObjectName("toolCheckbox_" + str(tool))
                toolCheckbox.setToolTip("Add T" + str(tool) + " to calibration.")
                toolCheckbox.setChecked(True)
                toolCheckbox.setCheckable(True)
                toolCheckbox.setObjectName("toolCheckbox_" + str(tool))
                self.toolCheckboxes.append(toolCheckbox)

        # Display tool buttons
        for i, button in enumerate(self.toolButtons):
            button.setCheckable(True)
            index = button.objectName()
            index = int(index[-1:])
            if int(self.__activePrinter["currentTool"]) == index:
                button.setChecked(True)
            else:
                button.setChecked(False)
            # button.clicked.connect(self.callTool)
            self.jogPanel.addWidget(
                button, (7 + i), 0, Qt.AlignCenter | Qt.AlignHCenter
            )

        # Display tool checkboxes
        for i, checkbox in enumerate(self.toolCheckboxes):
            checkbox.setCheckable(True)
            checkbox.setChecked(True)
            # button.clicked.connect(self.callTool)
            self.jogPanel.addWidget(
                checkbox, (7 + i), 1, Qt.AlignCenter | Qt.AlignHCenter
            )
        # Alignment/Detection state reset
        self.state = 0
        # Endstop calibration state flags
        self.__stateManualCPCapture = False
        self.__stateAutoCPCapture = False
        self.__stateEndstopAutoCalibrate = False
        self.toggleEndstopAutoDetectionSignal.emit(False)
        # Nozzle calibration state flags
        self.__stateOverrideManualNozzleAlignment = False
        self.__stateAutoNozzleAlignment = False
        self.toggleNozzleAutoDetectionSignal.emit(False)
        # Crosshair display button
        self.crosshairDisplayButton.setVisible(True)
        self.crosshairDisplayButton.setDisabled(False)
        if self.__displayCrosshair:
            self.crosshairDisplayButton.setStyleSheet(self.styleOrange)
            self.crosshairDisplayButton.setChecked(True)
        else:
            self.crosshairDisplayButton.setStyleSheet(self.styleBlue)
            self.crosshairDisplayButton.setChecked(False)

        _logger.debug("Tool data and interface created successfully.")

    def stateCPSetup(self):
        # Settings option in menu
        self.preferencesAction.setDisabled(False)
        # Connect button
        self.connectButton.setVisible(False)
        self.connectButton.setDisabled(True)
        self.connectButton.setStyleSheet(self.styleDisabled)
        # Disconnect button
        self.disconnectButton.setVisible(True)
        self.disconnectButton.setDisabled(False)
        self.disconnectButton.setStyleSheet(self.styleRed)
        self.disconnectButton.setText("C")
        self.disconnectButton.setToolTip("Cancel..")
        # Setup CP button
        self.cpSetupButton.setVisible(True)
        self.cpSetupButton.setDisabled(True)
        self.cpSetupButton.setStyleSheet(self.styleDisabled)
        # CP Automated Capture button
        self.cpAutoCaptureButton.setVisible(True)
        self.cpAutoCaptureButton.setDisabled(False)
        self.cpAutoCaptureButton.setStyleSheet(self.styleOrange)
        # Manual capture button
        self.manualCPCaptureButton.setVisible(True)
        self.manualCPCaptureButton.setDisabled(False)
        self.manualCPCaptureButton.setStyleSheet(self.styleGreen)
        # Start Alignment button
        self.startAlignToolsButton.setVisible(False)
        self.startAlignToolsButton.setDisabled(True)
        self.startAlignToolsButton.setText("Align Tools")
        self.startAlignToolsButton.setStyleSheet(self.styleDisabled)
        # Override Manual Tool offset Capture button
        self.overrideManualOffsetCaptureButton.setVisible(False)
        self.overrideManualOffsetCaptureButton.setDisabled(True)
        self.overrideManualOffsetCaptureButton.setStyleSheet(self.styleDisabled)
        # Manual Tool offset Capture button
        self.manualToolOffsetCaptureButton.setDisabled(True)
        self.manualToolOffsetCaptureButton.setVisible(False)
        self.manualToolOffsetCaptureButton.setStyleSheet(self.styleDisabled)
        # Resume auto alignment button
        self.resumeAutoToolAlignmentButton.setVisible(False)
        self.resumeAutoToolAlignmentButton.setDisabled(True)
        self.resumeAutoToolAlignmentButton.setStyleSheet(self.styleDisabled)
        # Crosshair display button
        self.crosshairDisplayButton.setVisible(True)
        self.crosshairDisplayButton.setDisabled(False)
        if self.__displayCrosshair:
            self.crosshairDisplayButton.setStyleSheet(self.styleOrange)
            self.crosshairDisplayButton.setChecked(True)
        else:
            self.crosshairDisplayButton.setStyleSheet(self.styleBlue)
            self.crosshairDisplayButton.setChecked(False)
        # Jog panel tab
        self.tabPanel.setDisabled(False)

    def stateCPAuto(self):
        # Settings option in menu
        self.preferencesAction.setDisabled(False)
        # Connect button
        self.connectButton.setVisible(False)
        self.connectButton.setDisabled(True)
        self.connectButton.setStyleSheet(self.styleDisabled)
        # Disconnect button
        self.disconnectButton.setVisible(True)
        self.disconnectButton.setDisabled(False)
        self.disconnectButton.setStyleSheet(self.styleRed)
        self.disconnectButton.setText("C")
        self.disconnectButton.setToolTip("Cancel..")
        # Setup CP button
        self.cpSetupButton.setVisible(True)
        self.cpSetupButton.setDisabled(True)
        self.cpSetupButton.setStyleSheet(self.styleDisabled)
        # CP Automated Capture button
        self.cpAutoCaptureButton.setVisible(True)
        self.cpAutoCaptureButton.setDisabled(True)
        self.cpAutoCaptureButton.setStyleSheet(self.styleDisabled)
        # Manual capture button
        self.manualCPCaptureButton.setVisible(False)
        self.manualCPCaptureButton.setDisabled(True)
        self.manualCPCaptureButton.setStyleSheet(self.styleDisabled)
        # Start Alignment button
        self.startAlignToolsButton.setVisible(False)
        self.startAlignToolsButton.setDisabled(True)
        self.startAlignToolsButton.setText("Align Tools")
        self.startAlignToolsButton.setStyleSheet(self.styleDisabled)
        # Override Manual Tool offset Capture button
        self.overrideManualOffsetCaptureButton.setVisible(False)
        self.overrideManualOffsetCaptureButton.setDisabled(True)
        self.overrideManualOffsetCaptureButton.setStyleSheet(self.styleDisabled)
        # Manual Tool offset Capture button
        self.manualToolOffsetCaptureButton.setDisabled(True)
        self.manualToolOffsetCaptureButton.setVisible(False)
        self.manualToolOffsetCaptureButton.setStyleSheet(self.styleDisabled)
        # Resume auto alignment button
        self.resumeAutoToolAlignmentButton.setVisible(False)
        self.resumeAutoToolAlignmentButton.setDisabled(True)
        self.resumeAutoToolAlignmentButton.setStyleSheet(self.styleDisabled)
        # Crosshair display button
        self.crosshairDisplayButton.setVisible(True)
        self.crosshairDisplayButton.setDisabled(True)
        self.crosshairDisplayButton.setStyleSheet(self.styleDisabled)
        self.crosshairDisplayButton.setChecked(False)
        # Jog panel tab
        self.tabPanel.setDisabled(True)

    def stateCalibrateReady(self):
        # Settings option in menu
        self.preferencesAction.setDisabled(False)
        # Connect button
        self.connectButton.setVisible(False)
        self.connectButton.setDisabled(True)
        self.connectButton.setStyleSheet(self.styleDisabled)
        # Disconnect button
        self.disconnectButton.setVisible(True)
        self.disconnectButton.setDisabled(False)
        self.disconnectButton.setStyleSheet(self.styleRed)
        self.disconnectButton.setText("C")
        self.disconnectButton.setToolTip("Cancel..")
        # Setup CP button
        self.cpSetupButton.setVisible(True)
        self.cpSetupButton.setDisabled(False)
        self.cpSetupButton.setStyleSheet(self.styleBlue)
        # CP Automated Capture button
        self.cpAutoCaptureButton.setVisible(False)
        self.cpAutoCaptureButton.setDisabled(True)
        self.cpAutoCaptureButton.setStyleSheet(self.styleDisabled)
        # Manual capture button
        self.manualCPCaptureButton.setVisible(False)
        self.manualCPCaptureButton.setDisabled(True)
        self.manualCPCaptureButton.setStyleSheet(self.styleDisabled)
        # Start Alignment button
        self.startAlignToolsButton.setVisible(True)
        self.startAlignToolsButton.setDisabled(False)
        self.startAlignToolsButton.setText("Align Tools")
        self.startAlignToolsButton.setStyleSheet(self.styleGreen)
        # Override Manual Tool offset Capture button
        self.overrideManualOffsetCaptureButton.setVisible(False)
        self.overrideManualOffsetCaptureButton.setDisabled(True)
        self.overrideManualOffsetCaptureButton.setStyleSheet(self.styleDisabled)
        # Manual Tool offset Capture button
        self.manualToolOffsetCaptureButton.setDisabled(True)
        self.manualToolOffsetCaptureButton.setVisible(False)
        self.manualToolOffsetCaptureButton.setStyleSheet(self.styleDisabled)
        # Resume auto alignment button
        self.resumeAutoToolAlignmentButton.setVisible(False)
        self.resumeAutoToolAlignmentButton.setDisabled(True)
        self.resumeAutoToolAlignmentButton.setStyleSheet(self.styleDisabled)
        # Crosshair display button
        self.crosshairDisplayButton.setVisible(True)
        self.crosshairDisplayButton.setDisabled(False)
        if self.__displayCrosshair:
            self.crosshairDisplayButton.setStyleSheet(self.styleOrange)
            self.crosshairDisplayButton.setChecked(True)
        else:
            self.crosshairDisplayButton.setStyleSheet(self.styleBlue)
            self.crosshairDisplayButton.setChecked(False)
        # Jog panel tab
        self.tabPanel.setDisabled(False)
        # Tool buttons
        for button in self.toolButtons:
            button.setStyleSheet("")
            button.setDisabled(False)

    def stateCalibtrateRunning(self):
        # Settings option in menu
        self.preferencesAction.setDisabled(True)
        # Connect button
        self.connectButton.setVisible(False)
        self.connectButton.setDisabled(True)
        self.connectButton.setStyleSheet(self.styleDisabled)
        # Disconnect button
        self.disconnectButton.setVisible(True)
        self.disconnectButton.setDisabled(False)
        self.disconnectButton.setStyleSheet(self.styleRed)
        self.disconnectButton.setText("C")
        self.disconnectButton.setToolTip("Cancel..")
        # Setup CP button
        self.cpSetupButton.setVisible(True)
        self.cpSetupButton.setDisabled(True)
        self.cpSetupButton.setStyleSheet(self.styleDisabled)
        # CP Automated Capture button
        self.cpAutoCaptureButton.setVisible(False)
        self.cpAutoCaptureButton.setDisabled(True)
        self.cpAutoCaptureButton.setStyleSheet(self.styleDisabled)
        # Manual capture button
        self.manualCPCaptureButton.setVisible(False)
        self.manualCPCaptureButton.setDisabled(True)
        self.manualCPCaptureButton.setStyleSheet(self.styleDisabled)
        # Start Alignment button
        self.startAlignToolsButton.setVisible(False)
        self.startAlignToolsButton.setDisabled(True)
        self.startAlignToolsButton.setText("Detecting..")
        self.startAlignToolsButton.setStyleSheet(self.styleOrange + " * {font: italic}")
        # Override Manual Tool offset Capture button
        self.overrideManualOffsetCaptureButton.setVisible(True)
        self.overrideManualOffsetCaptureButton.setDisabled(True)
        self.overrideManualOffsetCaptureButton.setStyleSheet(self.styleDisabled)
        # Manual Tool offset Capture button
        self.manualToolOffsetCaptureButton.setDisabled(True)
        self.manualToolOffsetCaptureButton.setVisible(False)
        self.manualToolOffsetCaptureButton.setStyleSheet(self.styleDisabled)
        # Resume auto alignment button
        self.resumeAutoToolAlignmentButton.setVisible(False)
        self.resumeAutoToolAlignmentButton.setDisabled(True)
        self.resumeAutoToolAlignmentButton.setStyleSheet(self.styleDisabled)
        # Crosshair display button
        self.crosshairDisplayButton.setVisible(True)
        self.crosshairDisplayButton.setDisabled(True)
        self.crosshairDisplayButton.setStyleSheet(self.styleDisabled)
        self.crosshairDisplayButton.setChecked(False)
        # Jog panel tab
        self.tabPanel.setDisabled(True)
        # Tool selection buttons disable
        for button in self.toolButtons:
            button.setDisabled(True)

    def stateCalibrateComplete(self):
        # Settings option in menu
        self.preferencesAction.setDisabled(False)
        # Connect button
        self.connectButton.setVisible(False)
        self.connectButton.setDisabled(True)
        self.connectButton.setStyleSheet(self.styleDisabled)
        # Disconnect button
        self.disconnectButton.setVisible(True)
        self.disconnectButton.setDisabled(False)
        self.disconnectButton.setStyleSheet(self.styleRed)
        self.disconnectButton.setText("D")
        self.disconnectButton.setToolTip("Disconnect..")
        # Setup CP button
        self.cpSetupButton.setVisible(True)
        self.cpSetupButton.setDisabled(False)
        self.cpSetupButton.setStyleSheet(self.styleBlue)
        # CP Automated Capture button
        self.cpAutoCaptureButton.setVisible(False)
        self.cpAutoCaptureButton.setDisabled(True)
        self.cpAutoCaptureButton.setStyleSheet(self.styleDisabled)
        # Manual capture button
        self.manualCPCaptureButton.setVisible(False)
        self.manualCPCaptureButton.setDisabled(True)
        self.manualCPCaptureButton.setStyleSheet(self.styleDisabled)
        # Start Alignment button
        self.startAlignToolsButton.setVisible(True)
        self.startAlignToolsButton.setDisabled(False)
        self.startAlignToolsButton.setText("Align Tools")
        self.startAlignToolsButton.setStyleSheet(self.styleGreen)
        # Override Manual Tool offset Capture button
        self.overrideManualOffsetCaptureButton.setVisible(False)
        self.overrideManualOffsetCaptureButton.setDisabled(True)
        self.overrideManualOffsetCaptureButton.setStyleSheet(self.styleDisabled)
        # Manual Tool offset Capture button
        self.manualToolOffsetCaptureButton.setDisabled(True)
        self.manualToolOffsetCaptureButton.setVisible(False)
        self.manualToolOffsetCaptureButton.setStyleSheet(self.styleDisabled)
        # Resume auto alignment button
        self.resumeAutoToolAlignmentButton.setVisible(False)
        self.resumeAutoToolAlignmentButton.setDisabled(True)
        self.resumeAutoToolAlignmentButton.setStyleSheet(self.styleDisabled)
        # Crosshair display button
        self.crosshairDisplayButton.setVisible(True)
        self.crosshairDisplayButton.setDisabled(False)
        if self.__displayCrosshair:
            self.crosshairDisplayButton.setStyleSheet(self.styleOrange)
            self.crosshairDisplayButton.setChecked(True)
        else:
            self.crosshairDisplayButton.setStyleSheet(self.styleBlue)
            self.crosshairDisplayButton.setChecked(False)
        # Jog panel tab
        self.tabPanel.setDisabled(False)
        # Tool buttons
        for button in self.toolButtons:
            button.setStyleSheet("")
            button.setDisabled(False)

    def stateExiting(self):
        # Settings option in menu
        self.preferencesAction.setDisabled(True)
        # Connect button
        self.connectButton.setVisible(True)
        self.connectButton.setDisabled(True)
        self.connectButton.setStyleSheet(self.styleDisabled)
        # Disconnect button
        self.disconnectButton.setVisible(True)
        self.disconnectButton.setDisabled(True)
        self.disconnectButton.setStyleSheet(self.styleDisabled)
        self.disconnectButton.setText("-")
        self.disconnectButton.setToolTip("Disconnecting..")
        # Setup CP button
        self.cpSetupButton.setVisible(True)
        self.cpSetupButton.setDisabled(True)
        self.cpSetupButton.setStyleSheet(self.styleDisabled)
        # CP Automated Capture button
        self.cpAutoCaptureButton.setVisible(True)
        self.cpAutoCaptureButton.setDisabled(True)
        self.cpAutoCaptureButton.setStyleSheet(self.styleDisabled)
        # Manual capture button
        self.manualCPCaptureButton.setVisible(False)
        self.manualCPCaptureButton.setDisabled(True)
        self.manualCPCaptureButton.setStyleSheet(self.styleDisabled)
        # Start Alignment button
        self.startAlignToolsButton.setVisible(False)
        self.startAlignToolsButton.setDisabled(True)
        self.startAlignToolsButton.setText("Align Tools")
        self.startAlignToolsButton.setStyleSheet(self.styleGreen)
        # Override Manual Tool offset Capture button
        self.overrideManualOffsetCaptureButton.setVisible(False)
        self.overrideManualOffsetCaptureButton.setDisabled(True)
        self.overrideManualOffsetCaptureButton.setStyleSheet(self.styleDisabled)
        # Manual Tool offset Capture button
        self.manualToolOffsetCaptureButton.setDisabled(True)
        self.manualToolOffsetCaptureButton.setVisible(False)
        self.manualToolOffsetCaptureButton.setStyleSheet(self.styleDisabled)
        # Resume auto alignment button
        self.resumeAutoToolAlignmentButton.setVisible(False)
        self.resumeAutoToolAlignmentButton.setDisabled(True)
        self.resumeAutoToolAlignmentButton.setStyleSheet(self.styleDisabled)
        # Crosshair display button
        self.crosshairDisplayButton.setVisible(True)
        self.crosshairDisplayButton.setDisabled(True)
        self.crosshairDisplayButton.setStyleSheet(self.styleDisabled)
        self.crosshairDisplayButton.setChecked(False)
        # Jog panel tab
        self.tabPanel.setDisabled(True)

    ########################################################################### User interactions
    def setupCPCapture(self):
        self.__stateSetupCPCapture = True
        self.toggleEndstopDetectionSignal.emit(True)
        # enable detection
        self.toggleDetectionSignal.emit(True)
        self.__displayCrosshair = True
        # update machine coordinates
        self.pollCoordinatesSignal.emit()
        # Get original physical coordinates
        self.originalPrinterPosition = self.__currentPosition
        self.__restorePosition = copy.deepcopy(self.__currentPosition)
        self.resetCalibrationVariables()
        self.stateCPSetup()
        self.repaint()

    def manualCPCapture(self):
        self.__stateSetupCPCapture = False
        self.__stateManualCPCapture = True
        # update machine coordinates
        self.pollCoordinatesSignal.emit()
        # stop endstop detection
        self.toggleEndstopDetectionSignal.emit(False)
        # update GUI
        self.stateCalibrateReady()

    def setupCPAutoCapture(self):
        # send calling to log
        _logger.debug("*** calling App.setupCPAutoCapture")
        self.startTime = time.time()
        #################################### Camera Calibration
        # Update GUI state
        self.stateCPAuto()
        # set state flag to handle camera calibration
        self.__stateEndstopAutoCalibrate = True
        self.__stateAutoCPCapture = True
        # Start detector in DetectionManager
        self.toggleEndstopAutoDetectionSignal.emit(True)
        self.uv = [None, None]
        self.unloadToolSignal.emit()
        self.pollCoordinatesSignal.emit()
        # send exiting to log
        _logger.debug("*** exiting App.setupCPAutoCapture")

    def haltCPAutoCapture(self):
        self.resetCalibration()
        self.resetCalibrationVariables()
        self.statusBar.showMessage("CP calibration cancelled.")
        # Reset GUI
        self.stateConnected()

    def haltNozzleCapture(self):
        self.resetNozzleAlignment()
        self.statusBar.showMessage("Nozzle calibration halted.")
        # Reset GUI
        self.stateCalibrateReady()

    def overrideManualToolOffsetCapture(self):
        self.overrideManualOffsetCaptureButton.setDisabled(True)
        self.overrideManualOffsetCaptureButton.setStyleSheet(self.styleDisabled)
        # set tool alignment state to trigger offset calculation
        self.state = 100
        self.pollCoordinatesSignal.emit()

    def manualToolOffsetCapture(self):
        self.manualToolOffsetCaptureButton.setDisabled(True)
        self.manualToolOffsetCaptureButton.setVisible(False)
        self.manualToolOffsetCaptureButton.setStyleSheet(self.styleDisabled)
        params = {
            "toolIndex": int(self.__activePrinter["currentTool"]),
            "position": self.__currentPosition,
            "cpCoordinates": self.__cpCoordinates,
            "continue": False,
        }
        self.setOffsetsSignal.emit(params)

    def resetCalibration(self):
        # Reset program state, and frame capture control to defaults
        self.__stateEndstopAutoCalibrate = False
        self.__stateAutoCPCapture = False
        self.__stateSetupCPCapture = False
        self.__stateOverrideManualNozzleAlignment = False
        self.__stateAutoNozzleAlignment = False
        self.toggleEndstopAutoDetectionSignal.emit(False)
        self.toggleNozzleAutoDetectionSignal.emit(False)
        self.toggleEndstopDetectionSignal.emit(False)
        self.toggleDetectionSignal.emit(False)
        self.__displayCrosshair = False
        self.resetCalibrationVariables()
        if self.__restorePosition is not None:
            self.unloadToolSignal.emit()
        self.getVideoFrameSignal.emit()

    def resetNozzleAlignment(self):
        # Reset program state, and frame capture control to defaults
        self.__stateEndstopAutoCalibrate = False
        self.__stateAutoCPCapture = False
        self.__stateSetupCPCapture = False
        self.__stateOverrideManualNozzleAlignment = False
        self.__stateAutoNozzleAlignment = False
        self.toggleEndstopAutoDetectionSignal.emit(False)
        self.toggleNozzleAutoDetectionSignal.emit(False)
        self.toggleEndstopDetectionSignal.emit(False)
        self.toggleDetectionSignal.emit(False)
        self.__displayCrosshair = False
        self.resetCalibrationVariables()
        self.tabPanel.setDisabled(True)
        self.unloadToolSignal.emit()
        self.getVideoFrameSignal.emit()

    # Function to reset calibrateTools variables
    def resetCalibrationVariables(self):
        # Setup camera calibration move coordinates
        self.calibrationCoordinates = [
            [0, -0.5],
            [0.294, -0.405],
            [0.476, -0.155],
            [0.476, 0.155],
            [0.294, 0.405],
            [0, 0.5],
            [-0.294, 0.405],
            [-0.476, 0.155],
            [-0.476, -0.155],
            [-0.294, -0.405],
        ]
        # reset all variables
        self.guessPosition = [1, 1]
        self.uv = [None, None]
        self.olduv = self.uv
        if self.transformMatrix is None or self.mpp is None:
            _logger.debug("Camera calibration matrix reset.")
            self.state = 0
        elif len(self.transformMatrix) < 6:
            self.transformMatrix = None
            self.mpp = None
            self.state = 0
        else:
            self.state = 200
        self.detect_count = 0
        self.space_coordinates = []
        self.camera_coordinates = []
        self.retries = 0
        self.calibrationMoves = 0
        self.repeatCounter = 0

    def startAlignTools(self):
        # send calling to log
        _logger.debug("*** calling App.startAlignTools")
        self.startTime = time.time()
        # start as automated alignment state
        self.__stateOverrideManualNozzleAlignment = False
        self.__stateAutoNozzleAlignment = True

        # Update GUI state
        self.stateCalibtrateRunning()
        self.updateStatusbarMessage("Starting tool alignment..")

        # Create array for tools included in alignment process
        self.alignmentToolSet = []
        self.workingToolset = None
        for checkbox in self.toolCheckboxes:
            if checkbox.isChecked():
                self.alignmentToolSet.append(int(checkbox.objectName()[13:]))
        if len(self.alignmentToolSet) > 0:
            self.toggleNozzleAutoDetectionSignal.emit(True)
            self.calibrateTools(self.alignmentToolSet)
        else:
            # tell user no tools selected
            errorMsg = "No tools selected for alignment"
            self.updateStatusbarMessage(errorMsg)
            _logger.info(errorMsg)
            self.haltNozzleCapture()
        # send exiting to log
        _logger.debug("*** exiting App.startAlignTools")

    def identifyToolButton(self):
        self.tabPanel.setDisabled(True)
        sender = self.sender()
        for button in self.toolButtons:
            if button.objectName() != sender.objectName():
                button.setChecked(False)
        toolIndex = int(sender.objectName()[11:])
        if toolIndex != int(self.__activePrinter["currentTool"]):
            self.updateStatusbarMessage(">>> Loading T" + str(toolIndex) + ".. >>>")
            self.callTool(toolIndex)
        else:
            self.updateStatusbarMessage("<<< Unloading tool.. <<<")
            self.callTool(-1)

    def calibrateTools(self, toolset=None):
        # toolset is passed the first time we call the function
        # this creates the workingToolset, from which we pop each tool on each cycle
        if toolset is not None:
            self.workingToolset = toolset
        # check if we still have tools to calibrate in the workingToolset list
        if len(self.workingToolset) > 0:
            # grab the first item in the list (FIFO)
            toolIndex = self.workingToolset[0]
            _logger.info("Calibrating T" + str(toolIndex) + "..")
            self.startAlignToolsButton.setText("Detecting T" + str(toolIndex) + "..")
            # delete the tool from the list before processing it
            self.workingToolset.pop(0)
            # update toolButtons GUI to indiciate which tool we're working on
            for button in self.toolButtons:
                buttonName = "toolButton_" + str(toolIndex)
                if button.objectName() == buttonName:
                    button.setStyleSheet(self.styleOrange)
            self.resetCalibrationVariables()
            # main program state flags
            self.__stateOverrideManualNozzleAlignment = False
            self.__stateAutoNozzleAlignment = True
            # DetectionManager state flag
            self.toggleNozzleAutoDetectionSignal.emit(True)
            # Capture start time of tool calibration run
            self.toolTime = time.time()
            # Call tool and start calibration
            self.callTool(toolIndex)
        else:
            # entire list has been processed, output results
            calibration_time = np.around(time.time() - self.startTime, 1)
            _logger.info(
                "Calibration completed ("
                + str(calibration_time)
                + "s) with a resolution of "
                + str(self.mpp)
                + "/pixel"
            )
            # save to firmware
            self.saveOffsets()
            # reset GUI
            self.stateCalibrateComplete()
            self.repaint()
            # reset state flags for main program and Detection Manager
            self.resetNozzleAlignment()

    def autoCalibrate(self):
        self.tabPanel.setDisabled(True)
        # create variable for tracking the calibration run time, if not already defined
        try:
            if runtime:
                pass
        except:
            runtime = time.time()
        if self.uv is not None:
            if self.uv[0] is not None and self.uv[1] is not None:
                # First calibration step
                if self.state == 0:
                    _logger.debug(
                        "*** State: "
                        + str(self.state)
                        + " Coords:"
                        + str(self.__currentPosition)
                        + " UV: "
                        + str(self.uv)
                        + " old UV: "
                        + str(self.olduv)
                    )
                    self.updateStatusbarMessage("Calibrating camera step 0..")
                    if self.olduv is not None:
                        if self.olduv[0] == self.uv[0] and self.olduv[1] == self.uv[1]:
                            self.repeatCounter += 1
                            if self.repeatCounter > 5:
                                self.nozzleDetectionFailed()
                                return
                            # loop through again
                            self.retries += 1
                            self.pollCoordinatesSignal.emit()
                            return
                        else:
                            self.repeatCounter = 0
                    self.olduv = self.uv
                    self.space_coordinates = []
                    self.camera_coordinates = []

                    self.space_coordinates.append(
                        (self.__currentPosition["X"], self.__currentPosition["Y"])
                    )
                    self.camera_coordinates.append((self.uv[0], self.uv[1]))

                    # move carriage for calibration
                    self.offsetX = self.calibrationCoordinates[0][0]
                    self.offsetY = self.calibrationCoordinates[0][1]
                    params = {"position": {"X": self.offsetX, "Y": self.offsetY}}
                    self.lastState = 0
                    self.state = 1
                    self.moveRelativeSignal.emit(params)
                    return
                elif self.state >= 1 and self.state < len(self.calibrationCoordinates):
                    # capture the UV data when a calibration move has been executed, before returning to original position
                    if self.state != self.lastState and self.state < len(
                        self.calibrationCoordinates
                    ):
                        _logger.debug(
                            "*** State: "
                            + str(self.state)
                            + " Coords:"
                            + str(self.__currentPosition)
                            + " UV: "
                            + str(self.uv)
                            + " old UV: "
                            + str(self.olduv)
                        )
                        if self.olduv is not None:
                            if (
                                self.olduv[0] == self.uv[0]
                                and self.olduv[1] == self.uv[1]
                            ):
                                self.repeatCounter += 1
                                if self.repeatCounter > 10:
                                    self.nozzleDetectionFailed()
                                    return
                                # loop through again
                                self.retries += 1
                                self.pollCoordinatesSignal.emit()
                                return
                            else:
                                self.repeatCounter = 0
                        # Calculate mpp at first move
                        if self.state == 1:
                            self.mpp = np.around(
                                0.5
                                / self.getDistance(
                                    self.olduv[0], self.olduv[1], self.uv[0], self.uv[1]
                                ),
                                3,
                            )
                        # save position as previous position
                        self.olduv = self.uv
                        # save machine coordinates for detected nozzle
                        self.space_coordinates.append(
                            (self.__currentPosition["X"], self.__currentPosition["Y"])
                        )
                        # save camera coordinates
                        self.camera_coordinates.append((self.uv[0], self.uv[1]))

                        # return carriage to relative center of movement
                        self.offsetX = -1 * self.offsetX
                        self.offsetY = -1 * self.offsetY
                        self.lastState = self.state
                        params = {"position": {"X": self.offsetX, "Y": self.offsetY}}
                        self.moveRelativeSignal.emit(params)
                        return
                    # otherwise, move the carriage from the original position to the next step and increment state
                    else:
                        self.updateStatusbarMessage(
                            "Calibrating camera step " + str(self.state) + ".."
                        )
                        _logger.debug(
                            "Step " + str(self.state) + " detection UV: " + str(self.uv)
                        )
                        # move carriage to next calibration point
                        self.offsetX = self.calibrationCoordinates[self.state][0]
                        self.offsetY = self.calibrationCoordinates[self.state][1]
                        self.lastState = int(self.state)
                        self.state += 1
                        params = {"position": {"X": self.offsetX, "Y": self.offsetY}}
                        self.moveRelativeSignal.emit(params)
                        return
                elif self.state == len(self.calibrationCoordinates):
                    # Camera calibration moves completed.
                    if self.olduv is not None:
                        if self.olduv[0] == self.uv[0] and self.olduv[1] == self.uv[1]:
                            self.repeatCounter += 1
                            if self.repeatCounter > 10:
                                self.nozzleDetectionFailed()
                                return
                            # loop through again
                            self.retries += 1
                            self.pollCoordinatesSignal.emit()
                            return
                        else:
                            self.repeatCounter = 0
                    # Update GUI thread with current status and percentage complete
                    updateMessage = "Millimeters per pixel is " + str(self.mpp)
                    self.updateStatusbarMessage(updateMessage)
                    _logger.info(updateMessage)

                    # save position as previous position
                    self.olduv = self.uv
                    # save machine coordinates for detected nozzle
                    self.space_coordinates.append(
                        (self.__currentPosition["X"], self.__currentPosition["Y"])
                    )
                    # save camera coordinates
                    self.camera_coordinates.append((self.uv[0], self.uv[1]))

                    # calculate camera transformation matrix
                    cameraCalibrationTime = np.around(time.time() - self.startTime, 1)
                    _logger.info(
                        "Camera calibrated ("
                        + str(cameraCalibrationTime)
                        + "s); aligning.."
                    )

                    # Calculate transformation matrix
                    self.transform_input = [
                        (self.space_coordinates[i], self.normalize_coords(camera))
                        for i, camera in enumerate(self.camera_coordinates)
                    ]
                    (
                        self.transformMatrix,
                        self.transform_residual,
                    ) = self.least_square_mapping(self.transform_input)

                    # define camera center in machine coordinate space
                    self.newCenter = self.transformMatrix.T @ np.array(
                        [0, 0, 0, 0, 0, 1]
                    )
                    self.guessPosition[0] = np.around(self.newCenter[0], 3)
                    self.guessPosition[1] = np.around(self.newCenter[1], 3)
                    _logger.info(
                        "Calibration positional guess: " + str(self.guessPosition)
                    )

                    # Set next calibration variables state
                    self.state = 200
                    self.retries = 0
                    self.calibrationMoves = 0

                    params = {
                        "position": {
                            "X": self.guessPosition[0],
                            "Y": self.guessPosition[1],
                        }
                    }
                    self.moveAbsoluteSignal.emit(params)
                    return
                elif self.state == 200:
                    # Update GUI with current status
                    if self.__stateEndstopAutoCalibrate:
                        updateMessage = (
                            "Endstop calibration step "
                            + str(self.calibrationMoves)
                            + ".. (MPP="
                            + str(self.mpp)
                            + ")"
                        )
                    else:
                        updateMessage = (
                            "Tool "
                            + str(self.__activePrinter["currentTool"])
                            + " calibration step "
                            + str(self.calibrationMoves)
                            + ".. (MPP="
                            + str(self.mpp)
                            + ")"
                        )
                    self.updateStatusbarMessage(updateMessage)
                    # if(self.olduv is not None):
                    #     if(self.olduv[0] == self.uv[0] and self.olduv[1] == self.uv[1]):
                    #         # print('Repeating detection: ' + str(self.repeatCounter))
                    #         self.repeatCounter += 1
                    #         if(self.repeatCounter > 10):
                    #             print('Failed to detect.')
                    #             self.nozzleDetectionFailed()
                    #             return
                    #         # loop through again
                    #         print('Retrying', self.retries)
                    #         self.retries += 1
                    #         self.pollCoordinatesSignal.emit()
                    #         return
                    #     else:
                    #         # print('Took ' + str(self.repeatCounter) + ' attempts.')
                    #         self.repeatCounter = 0
                    # increment moves counter
                    self.calibrationMoves += 1
                    # nozzle detected, frame rotation is set, start
                    self.cx, self.cy = self.normalize_coords(self.uv)
                    self.v = [
                        self.cx**2,
                        self.cy**2,
                        self.cx * self.cy,
                        self.cx,
                        self.cy,
                        0,
                    ]
                    self.offsets = -1 * (0.55 * self.transformMatrix.T @ self.v)
                    self.offsets[0] = np.around(self.offsets[0], 3)
                    self.offsets[1] = np.around(self.offsets[1], 3)
                    _logger.debug(
                        "*** State: "
                        + str(self.state)
                        + " retries: "
                        + str(self.retries)
                        + " X"
                        + str(self.__currentPosition["X"])
                        + " Y"
                        + str(self.__currentPosition["Y"])
                        + " UV: "
                        + str(self.uv)
                        + " old UV: "
                        + str(self.olduv)
                        + " Offsets: "
                        + str(self.offsets)
                    )
                    # Add rounding handling for endstop alignment
                    if self.__stateEndstopAutoCalibrate:
                        if abs(self.offsets[0]) + abs(self.offsets[1]) <= 0.02:
                            self.offsets[0] = 0.0
                            self.offsets[1] = 0.0

                    # Start timer if we're calibrating the CP using the automated endstop detection
                    try:
                        if self.toolTime:
                            pass
                    except:
                        self.toolTime = time.time()

                    # calculate current calibration cycle runtime
                    runtime = np.around(time.time() - self.toolTime, 1)
                    # check if too much time has passed
                    if runtime > 120 or self.calibrationMoves > 30:
                        print("Runtime:", runtime, " moves: ", self.calibrationMoves)
                        self.retries = 10
                    # Otherwise, check if we're not aligned to the center
                    elif self.offsets[0] != 0.0 or self.offsets[1] != 0.0:
                        self.olduv = self.uv
                        params = {
                            "position": {"X": self.offsets[0], "Y": self.offsets[1]},
                            "moveSpeed": 1000,
                        }
                        self.moveRelativeSignal.emit(params)
                        _logger.debug(
                            "Calibration move X{0:-1.3f} Y{1:-1.3f} F1000 ".format(
                                self.offsets[0], self.offsets[1]
                            )
                        )
                        return
                    # finally, we're aligned to the center, and we should update the tool offsets
                    elif self.offsets[0] == 0.0 and self.offsets[1] == 0.0:
                        # endstop calibration wrapping up
                        if self.__stateEndstopAutoCalibrate:
                            updateMessage = (
                                "Endstop auto-calibrated in "
                                + str(self.calibrationMoves)
                                + " steps. (MPP="
                                + str(self.mpp)
                                + ")"
                            )
                            # update state flags for endstop alignment
                            self.__stateAutoCPCapture = False
                            self.__stateEndstopAutoCalibrate = False
                            self.__stateManualCPCapture = False
                            # update detection manager state
                            self.toggleEndstopAutoDetectionSignal.emit(False)
                            # disable detection manager frame analysis
                            self.toggleDetectionSignal.emit(False)
                            self.__displayCrosshair = False
                            # Set CP location
                            self.__cpCoordinates["X"] = np.around(
                                self.__currentPosition["X"], 2
                            )
                            self.__cpCoordinates["Y"] = np.around(
                                self.__currentPosition["Y"], 2
                            )
                            self.__cpCoordinates["Z"] = np.around(
                                self.__currentPosition["Z"], 2
                            )
                            # Update GUI statusbar with CP coordinates and green status
                            self.cpLabel.setText(
                                "<b>CP:</b> <i>("
                                + str(self.__cpCoordinates["X"])
                                + ", "
                                + str(self.__cpCoordinates["Y"])
                                + ")</i>"
                            )
                            self.cpLabel.setStyleSheet(self.styleGreen)
                            # Reset entire GUI for next state
                            self.stateCalibrateReady()
                            self.repaint()
                        # tool calibration wrapping up
                        elif self.__stateAutoNozzleAlignment:
                            updateMessage = (
                                "Tool "
                                + str(self.__activePrinter["currentTool"])
                                + " has been calibrated."
                            )
                            self.state = 100
                            self.retries = 0
                        self.updateStatusbarMessage(updateMessage)
                        self.pollCoordinatesSignal.emit()
                        return
            elif self.retries < 100 and runtime <= self.__maxRuntime:
                self.retries += 1
                self.pollCoordinatesSignal.emit()
                return
        if self.retries < self.__maxRetries:
            self.retries += 1
            # enable detection
            self.toggleDetectionSignal.emit(True)
            self.__displayCrosshair = True
            self.pollCoordinatesSignal.emit()
            return
        # If we've reached this part of the code, we've run over our limit of retries

    def nozzleDetectionFailed(self):
        self.state = -99
        # End auto calibration
        self.__stateAutoNozzleAlignment = False
        self.__stateOverrideManualNozzleAlignment = True
        # calibrating nozzle manual
        self.tabPanel.setDisabled(False)
        self.startAlignToolsButton.setVisible(False)
        self.startAlignToolsButton.setDisabled(True)
        self.overrideManualOffsetCaptureButton.setVisible(True)
        self.overrideManualOffsetCaptureButton.setDisabled(False)
        self.overrideManualOffsetCaptureButton.setStyleSheet(self.styleBlue)
        self.resumeAutoToolAlignmentButton.setVisible(True)
        self.resumeAutoToolAlignmentButton.setDisabled(False)
        self.resumeAutoToolAlignmentButton.setStyleSheet(self.styleGreen)
        self.toggleNozzleAutoDetectionSignal.emit(False)
        self.toggleNozzleDetectionSignal.emit(True)
        self.toggleDetectionSignal.emit(True)
        self.__displayCrosshair = True

    def resumeAutoAlignment(self):
        if self.transformMatrix is None or self.mpp is None:
            self.state = 0
        elif len(self.transformMatrix) < 6:
            self.transformMatrix = None
            self.mpp = None
            self.state = 0
        else:
            self.state = 200
        self.retries = 0
        self.repeatCounter = 0
        self.uv = [None, None]
        self.olduv = [None, None]
        self.__stateAutoNozzleAlignment = True
        self.toolTime = time.time()
        self.resumeAutoToolAlignmentButton.setVisible(False)
        self.resumeAutoToolAlignmentButton.setDisabled(True)
        self.resumeAutoToolAlignmentButton.setStyleSheet(self.styleDisabled)
        self.overrideManualOffsetCaptureButton.setVisible(False)
        self.overrideManualOffsetCaptureButton.setDisabled(True)
        self.overrideManualOffsetCaptureButton.setStyleSheet(self.styleDisabled)
        self.startAlignToolsButton.setVisible(True)
        self.startAlignToolsButton.setDisabled(True)
        self.updateStatusbarMessage("Resuming auto detection of current tool..")
        self.toggleNozzleAutoDetectionSignal.emit(True)
        self.pollCoordinatesSignal.emit()

    ########################################################################### Interface with Detection Manager
    def createDetectionManagerThread(self, announce=True):
        if announce:
            _logger.info("  .. starting Detection Manager.. ")
        # Thread setup
        self.detectionThread = QThread()
        self.detectionManager = DetectionManager(
            videoSrc=self._videoSrc,
            width=self._cameraWidth,
            height=self._cameraHeight,
            parent=None,
        )
        self.detectionManager.moveToThread(self.detectionThread)

        # Thread management signals and slots
        self.detectionManager.errorSignal.connect(self.detectionManagerError)
        self.detectionThread.started.connect(self.detectionManager.processFrame)
        self.detectionThread.finished.connect(self.detectionManager.quit)
        self.detectionThread.finished.connect(self.detectionManager.deleteLater)
        self.detectionThread.finished.connect(self.detectionThread.deleteLater)

        # Video frame signals and slots
        self.detectionManager.detectionManagerNewFrameSignal.connect(self.refreshImage)
        self.detectionManager.detectionManagerReadySignal.connect(self.startVideo)
        self.getVideoFrameSignal.connect(self.detectionManager.processFrame)
        # Camera image properties signals and slots
        self.setImagePropertiesSignal.connect(
            self.detectionManager.relayImageProperties
        )
        self.resetImageSignal.connect(self.detectionManager.relayResetImage)
        # Endstop alignment signals and slots
        self.toggleEndstopDetectionSignal.connect(
            self.detectionManager.toggleEndstopDetection
        )
        self.toggleEndstopAutoDetectionSignal.connect(
            self.detectionManager.toggleEndstopAutoDetection
        )
        # Nozzle alignment signals and slots
        self.toggleNozzleDetectionSignal.connect(
            self.detectionManager.toggleNozzleDetection
        )
        self.toggleNozzleAutoDetectionSignal.connect(
            self.detectionManager.toggleNozzleAutoDetection
        )
        # UV coordinates update signals and slots
        self.getUVCoordinatesSignal.connect(self.detectionManager.sendUVCoorindates)
        self.detectionManager.detectionManagerUVCoordinatesSignal.connect(
            self.saveUVCoordinates
        )
        # Master detection swtich enable/disable
        self.toggleDetectionSignal.connect(self.detectionManager.enableDetection)

    @pyqtSlot(object)
    def startVideo(self, cameraProperties):
        # send calling to log
        _logger.debug("*** calling App.startVideo")
        # capture camera properties
        self.__activeCamera = cameraProperties
        self.startVideoSignal.emit()
        # send exiting to log
        _logger.debug("*** exiting App.startVideo")

    @pyqtSlot(object)
    def refreshImage(self, data):
        self.__mutex.lock()
        frame = data[0]
        self.image.setPixmap(frame)
        self.__mutex.unlock()
        self.getVideoFrameSignal.emit()

    @pyqtSlot(object)
    def updateStatusbarMessage(self, message):
        self.__mutex.lock()
        # send calling to log
        _logger.debug("*** calling App.updateStatusbarMessage")
        try:
            self.statusBar.showMessage(message)
            self.statusBar.setStyleSheet("")
        except:
            errorMsg = "Error sending message to statusbar."
            _logger.error(errorMsg)
        self.__mutex.unlock()
        app.processEvents()
        # send exiting to log
        _logger.debug("*** exiting App.updateStatusbarMessage")

    @pyqtSlot(object)
    def detectionManagerError(self, message):
        self.haltPrinterOperation(silent=True)
        # self.__mutex.lock()
        try:
            self.resetCalibration()
            self.stateExiting()
            self.statusBar.showMessage(message)
            self.statusBar.setStyleSheet(self.styleRed)
            self.cpLabel.setStyleSheet(self.styleOrange)
            self.cpLabel.setVisible(False)
            self.connectionStatusLabel.setStyleSheet(self.styleOrange)
            self.connectionStatusLabel.setText("<i>Critical Error</i>")
            self.__mutex.unlock()
            if self.__restorePosition is not None:
                self.moveAbsoluteSignal.emit(self.__restorePosition)
        except Exception as e:
            print(e)
            # self.__mutex.unlock()
            errorMsg = "Error sending message to statusbar."
            _logger.error(errorMsg)
        # Kill thread
        self.detectionThread.quit()
        self.detectionThread.wait(self.__detectionManagerThreadWaitTime)
        if self.__restorePosition is not None:
            self.printerThread.quit()
            self.printerThread.wait(self.__printerManagerThreadWaitTime)
        # display error image
        self.image.setPixmap(self.errorImage)

    ########################################################################### Interface with Printer Manager
    def createPrinterManagerThread(self, announce=True):
        if announce:
            _logger.info("  .. starting Printer Manager.. ")
        try:
            self.printerManager = PrinterManager(
                parent=None,
                firmwareList=self.__firmwareList,
                driverList=self.__driverList,
                announcemode=announce,
            )
            self.printerThread = QThread()
            self.printerManager.moveToThread(self.printerThread)

            self.printerManager.errorSignal.connect(self.printerError)
            # self.printerManager.printerDisconnectedSignal.connect(self.printerThread.quit)
            # self.printerManager.printerDisconnectedSignal.connect(self.printerManager.deleteLater)
            self.printerThread.finished.connect(self.printerManager.quit)
            self.printerThread.finished.connect(self.printerManager.deleteLater)
            self.printerThread.finished.connect(self.printerThread.deleteLater)

            # PrinterManager object signals
            self.printerManager.updateStatusbarSignal.connect(
                self.updateStatusbarMessage
            )
            self.printerManager.activePrinterSignal.connect(self.printerConnected)
            self.printerManager.printerDisconnectedSignal.connect(
                self.printerDisconnected
            )
            self.connectSignal.connect(self.printerManager.connectPrinter)
            self.disconnectSignal.connect(self.printerManager.disconnectPrinter)
            self.announceSignal.connect(self.printerManager.setAnnounceMode)

            self.moveRelativeSignal.connect(self.printerManager.moveRelative)
            self.moveAbsoluteSignal.connect(self.printerManager.moveAbsolute)
            self.printerManager.moveCompleteSignal.connect(self.printerMoveComplete)

            self.pollCoordinatesSignal.connect(self.printerManager.getCoordinates)
            self.printerManager.coordinatesSignal.connect(self.saveCurrentPosition)

            self.callToolSignal.connect(self.printerManager.callTool)
            self.unloadToolSignal.connect(self.printerManager.unloadTools)
            self.printerManager.toolLoadedSignal.connect(self.toolLoaded)
            self.pollCurrentToolSignal.connect(self.printerManager.currentTool)
            self.printerManager.toolIndexSignal.connect(self.registerActiveTool)

            self.printerManager.offsetsSetSignal.connect(self.calibrateOffsetsApplied)
            self.setOffsetsSignal.connect(self.printerManager.calibrationSetOffset)
            self.saveToFirmwareSignal.connect(self.printerManager.saveOffsets)

            self.printerThread.start()  # priority=QThread.TimeCriticalPriority)
        except Exception as e:
            print(e)
            errorMsg = "Failed to start PrinterManager."
            _logger.critical(errorMsg)
            self.printerError(errorMsg)

    def connectPrinter(self):
        self.connectButton.setStyleSheet(self.styleDisabled)
        self.connectButton.setDisabled(True)
        self.preferencesAction.setDisabled(True)
        self.statusBar.setStyleSheet("")
        self.connectionStatusLabel.setText("<i>Connecting..</i>")
        self.connectionStatusLabel.setStyleSheet(self.styleBlue)
        self.repaint()

        self.connection_dialog = ConnectionDialog(
            parent=self,
            newPrinter=False,
            settings=self.__userSettings,
            stylesheet=self.globalStylesheet,
        )
        connectionDialogReturn = self.connection_dialog.exec()
        # Destroy connection_dialog window
        self.connection_dialog = None

        if connectionDialogReturn == -2:
            # new printer definition
            pass
        elif connectionDialogReturn >= 0:
            # fetch printer from user objects
            self.__activePrinter = self.__userSettings["printer"][
                connectionDialogReturn
            ]
            try:
                self.announceSignal.emit(False)
                if self.printerThread.isRunning() is True:
                    # Printer already running, delete thread and restart
                    self.printerThread.quit()
                    self.printerThread.wait(self.__printerManagerThreadWaitTime)
                self.createPrinterManagerThread(announce=False)
            except:
                self.createPrinterManagerThread(announce=False)
            self.announceSignal.emit(True)
            self.connectSignal.emit(self.__activePrinter)
        else:
            # user closed window, update GUI back to default state
            # Settings option in menu
            self.preferencesAction.setDisabled(False)
            # Connect button
            self.connectButton.setVisible(True)
            self.connectButton.setDisabled(False)
            self.connectButton.setStyleSheet(self.styleGreen)

    def haltPrinterOperation(self, **kwargs):
        try:
            silent = kwargs["silent"]
        except:
            silent = False
        # disconnect button
        self.disconnectButton.setStyleSheet(self.styleDisabled)
        self.disconnectButton.setDisabled(True)
        # Cancel CP Capture
        if (
            self.__stateAutoCPCapture is True
            or self.__stateEndstopAutoCalibrate is True
            or self.__stateSetupCPCapture is True
        ):
            self.haltCPAutoCapture()
            return
        # Cancel Nozzle Detection
        if (
            self.__stateAutoNozzleAlignment is True
            or self.__stateOverrideManualNozzleAlignment is True
        ):
            self.haltNozzleCapture()
            return
        # Disconnect from printer
        # Status label
        self.connectionStatusLabel.setText("<i>Disconnecting..</i>")
        self.connectionStatusLabel.setStyleSheet(self.styleBlue)
        # Setup CP button
        self.cpSetupButton.setStyleSheet(self.styleDisabled)
        self.cpSetupButton.setDisabled(True)
        # CP Automated Capture button
        self.cpAutoCaptureButton.setDisabled(True)
        self.cpAutoCaptureButton.setStyleSheet(self.styleDisabled)
        # Jog panel
        self.tabPanel.setDisabled(True)
        self.repaint()
        params = {}
        if silent:
            params["noUpdate"] = True
        else:
            params["noUpdate"] = False
        # restore position
        if (
            self.__cpCoordinates["X"] is not None
            and self.__cpCoordinates["Y"] is not None
        ):
            _logger.debug("Restoring to CP position..")
            params["parkPosition"] = self.__cpCoordinates
            self.disconnectSignal.emit(params)
        elif self.__restorePosition is not None:
            _logger.debug("Restoring to master restore position..")
            params["parkPosition"] = self.__restorePosition
            self.disconnectSignal.emit(params)
        else:
            self.disconnectSignal.emit(params)
        self.resetCalibrationVariables()
        self.updateStatusbarMessage("Printer disconnected.")

    @pyqtSlot(object)
    def printerConnected(self, printerJSON):
        self.__mutex.lock()
        # send calling to log
        _logger.debug("*** calling App.printerConnected")
        self.__activePrinter = printerJSON
        # Status label
        self.connectionStatusLabel.setText(
            self.__activePrinter["nickname"]
            + " ["
            + self.__activePrinter["controller"]
            + " v"
            + self.__activePrinter["version"]
            + "]"
        )
        self.connectionStatusLabel.setStyleSheet(self.styleGreen)
        # poll for position
        self.__firstConnection = True
        self.__mutex.unlock()
        self.pollCoordinatesSignal.emit()
        # Gui state
        self.stateConnected()
        self.repaint()
        # send exiting to log
        _logger.debug("*** exiting App.printerConnected")

    @pyqtSlot(object)
    def printerDisconnected(self, **kwargs):
        self.__mutex.lock()
        try:
            message = kwargs["message"]
        except:
            message = None
        # send calling to log
        _logger.debug("*** calling App.printerDisconnected")
        # update status bar
        if message is not None:
            self.statusBar.showMessage(message)
            self.statusBar.setStyleSheet("")
        # CP Label
        self.cpLabel.setText("<b>CP:</b> <i>undef</i>")
        self.cpLabel.setStyleSheet(self.styleOrange)
        # Status label
        self.connectionStatusLabel.setText("Disconnected")
        self.connectionStatusLabel.setStyleSheet(self.styleOrange)
        self.__firstConnection = True
        self.__restorePosition = None
        self.__mutex.unlock()
        self.stateDisconnected()
        self.repaint()
        # send exiting to log
        _logger.debug("*** exiting App.printerDisconnected")

    @pyqtSlot(object)
    def printerError(self, message):
        _logger.debug("Printer Error: " + message)
        if self.__restorePosition is not None:
            params = {"parkPosition": self.__restorePosition}
            self.disconnectSignal.emit(params)
        else:
            self.disconnectSignal.emit(None)
        # Kill printer thread
        try:
            self.printerThread.quit()
            self.printerThread.wait(self.__printerManagerThreadWaitTime)
        except:
            _logger.warning("Printer thread not created yet.")
        self.printerDisconnected(message=message)
        self.statusBar.setStyleSheet(self.styleRed)

    def callTool(self, toolNumber=-1):
        # disable detection
        self.toggleDetectionSignal.emit(False)
        self.__displayCrosshair = False
        toolNumber = int(toolNumber)
        if toolNumber == -1:
            self.startAlignToolsButton.setText("Unloading..")
            self.unloadToolSignal.emit()
            return
        try:
            self.startAlignToolsButton.setText("Loading T" + str(toolNumber) + "..")
            self.callToolSignal.emit(toolNumber)
        except:
            errorMsg = "Unable to call tool from printer: " + str(toolNumber)
            _logger.error(errorMsg)
            self.printerError(errorMsg)

    @pyqtSlot()
    def toolLoaded(self):
        self.pollCurrentToolSignal.emit()
        if (
            self.__cpCoordinates["X"] is not None
            and self.__cpCoordinates["Y"] is not None
        ):
            params = {
                "protected": True,
                "moveSpeed": 5000,
                "position": {
                    "X": self.__cpCoordinates["X"],
                    "Y": self.__cpCoordinates["Y"],
                    "Z": self.__cpCoordinates["Z"],
                },
            }
        else:
            params = {
                "protected": True,
                "moveSpeed": 5000,
                "position": {
                    "X": self.__currentPosition["X"],
                    "Y": self.__currentPosition["Y"],
                    "Z": self.__currentPosition["Z"],
                },
            }
        self.moveAbsoluteSignal.emit(params)

    @pyqtSlot(int)
    def registerActiveTool(self, toolIndex):
        self.__mutex.lock()
        self.__activePrinter["currentTool"] = toolIndex
        for button in self.toolButtons:
            if button.objectName() != ("toolButton_" + str(toolIndex)):
                button.setChecked(False)
            else:
                button.setChecked(True)
        self.__mutex.unlock()
        if (
            self.__stateAutoNozzleAlignment is False
            and self.__stateOverrideManualNozzleAlignment is False
            and int(toolIndex) != -1
        ):
            self.startAlignToolsButton.setVisible(False)
            if (
                self.__cpCoordinates is not None
                and self.__cpCoordinates["X"] is not None
            ):
                self.manualToolOffsetCaptureButton.setEnabled(True)
                self.manualToolOffsetCaptureButton.setVisible(True)
                self.manualToolOffsetCaptureButton.setStyleSheet(self.styleGreen)
            else:
                self.manualToolOffsetCaptureButton.setEnabled(False)
                self.manualToolOffsetCaptureButton.setVisible(False)
                self.manualToolOffsetCaptureButton.setStyleSheet(self.styleDisabled)
        elif int(toolIndex) != -1:
            self.manualToolOffsetCaptureButton.setEnabled(False)
            self.manualToolOffsetCaptureButton.setVisible(False)
            self.manualToolOffsetCaptureButton.setStyleSheet(self.styleDisabled)
            self.startAlignToolsButton.setVisible(True)
            self.startAlignToolsButton.setText("Detecting T" + str(toolIndex) + "..")
        else:
            self.manualToolOffsetCaptureButton.setEnabled(False)
            self.manualToolOffsetCaptureButton.setVisible(False)
            self.manualToolOffsetCaptureButton.setStyleSheet(self.styleDisabled)
            self.startAlignToolsButton.setVisible(True)

    @pyqtSlot()
    def printerMoveComplete(self):
        self.tabPanel.setDisabled(False)
        if self.__stateAutoCPCapture and self.__stateEndstopAutoCalibrate:
            # enable detection
            self.toggleDetectionSignal.emit(True)
            self.__displayCrosshair = True
            statusMsg = "(Endstop auto detection active.)"
            self.updateStatusbarMessage(statusMsg)
            _logger.debug(statusMsg)
            # Calibrating camera, go based on state
            self.tabPanel.setDisabled(True)
        elif self.__stateAutoNozzleAlignment is True:
            # enable detection
            self.toggleDetectionSignal.emit(True)
            self.__displayCrosshair = True
            statusMsg = "(Tool/nozzle auto detection active.)"
            self.updateStatusbarMessage(statusMsg)
            _logger.debug(statusMsg)
            # calibrating nozzle auto
            self.tabPanel.setDisabled(True)
        elif self.__stateOverrideManualNozzleAlignment is True:
            # enable detection
            self.toggleDetectionSignal.emit(True)
            self.__displayCrosshair = True
            statusMsg = "(Tool/nozzle manual override active.)"
            self.updateStatusbarMessage(statusMsg)
            _logger.debug(statusMsg)
            # calibrating nozzle manual
            self.startAlignToolsButton.setVisible(False)
            self.startAlignToolsButton.setDisabled(True)
            self.manualCPCaptureButton.setVisible(True)
            return
        elif self.__stateManualCPCapture is True:
            statusMsg = "(Endstop/CP manual override active.)"
            self.updateStatusbarMessage(statusMsg)
            _logger.debug(statusMsg)
        else:
            statusMsg = "Ready."
            self.updateStatusbarMessage(statusMsg)
            _logger.debug(statusMsg)
        self.pollCoordinatesSignal.emit()

    @pyqtSlot(object)
    def saveUVCoordinates(self, uvCoordinates):
        self.uv = uvCoordinates
        if (
            self.__stateEndstopAutoCalibrate is True
            or self.__stateAutoNozzleAlignment is True
        ):
            if uvCoordinates is None:
                # failed to detect, poll coordinates again
                self.retries += 1
                self.startAlignToolsButton.setText(
                    "Retrying (" + str(self.retries) + ").."
                )
                # check if we've exceeded our maxRetries or maxRuntime
                if self.retries > self.__maxRetries:
                    if self.__stateEndstopAutoCalibrate is True:
                        self.updateStatusbarMessage("Failed to detect endstop.")
                        _logger.warning(
                            "Failed to detect endstop. Cancelled operation."
                        )
                        self.__stateAutoCPCapture = False
                        self.__stateEndstopAutoCalibrate = False
                        self.toggleEndstopAutoDetectionSignal.emit(False)
                        self.haltCPAutoCapture()
                    elif self.__stateAutoNozzleAlignment is True:
                        updateMessage = "Failed to detect nozzle. Try manual override."
                        self.updateStatusbarMessage(updateMessage)
                        _logger.warning(updateMessage)
                        self.nozzleDetectionFailed()
                        return
                self.pollCoordinatesSignal.emit()
                return
        self.autoCalibrate()

    @pyqtSlot(object)
    def saveCurrentPosition(self, coordinates):
        self.__mutex.lock()
        self.__currentPosition = coordinates
        self.__mutex.unlock()
        _logger.debug("Coordinates received:" + str(coordinates))
        self.toggleDetectionSignal.emit(True)
        self.__displayCrosshair = True
        if self.__stateManualCPCapture is True:
            _logger.debug("saveCurrentPosition: manual CP capture")
            self.__cpCoordinates = coordinates
            self.__stateManualCPCapture = False
            self.cpLabel.setText(
                "<b>CP:</b> <i>("
                + str(self.__cpCoordinates["X"])
                + ", "
                + str(self.__cpCoordinates["Y"])
                + ")</i>"
            )
            self.cpLabel.setStyleSheet(self.styleGreen)
            self.updateStatusbarMessage("CP captured.")
            self.repaint()
        elif (
            self.__stateEndstopAutoCalibrate is True
            or self.__stateAutoNozzleAlignment is True
        ):
            if self.state != 100:
                if int(self.__activePrinter["currentTool"]) > -1:
                    _logger.debug(
                        "saveCurrentPosition: autoCalibrate nozzle for T"
                        + str(int(self.__activePrinter["currentTool"]))
                    )
                else:
                    _logger.debug("saveCurrentPosition: autoCalibrate endstop.")
            elif self.state == 100:
                _logger.debug(
                    "saveCurrentPosition: autoCalibrate nozzle set offsets for T"
                    + str(int(self.__activePrinter["currentTool"]))
                )
                # set state to detect next tool
                self.state = 200
                self.__stateAutoNozzleAlignment = True
                self.toggleNozzleAutoDetectionSignal.emit(True)
                params = {
                    "toolIndex": int(self.__activePrinter["currentTool"]),
                    "position": coordinates,
                    "cpCoordinates": self.__cpCoordinates,
                    "continue": True,
                }
                self.setOffsetsSignal.emit(params)
                return
            self.getUVCoordinatesSignal.emit()
        elif self.__stateOverrideManualNozzleAlignment is True:
            _logger.debug(
                "saveCurrentPosition: manual nozzle set offsets for T"
                + str(int(self.__activePrinter["currentTool"]))
            )
            # set state to detect next tool
            self.state = 200
            self.__stateAutoNozzleAlignment = True
            self.toggleNozzleAutoDetectionSignal.emit(True)
            params = {
                "toolIndex": int(self.__activePrinter["currentTool"]),
                "position": coordinates,
                "cpCoordinates": self.__cpCoordinates,
                "continue": True,
            }
            self.setOffsetsSignal.emit(params)
            return
        elif self.__firstConnection:
            _logger.debug("saveCurrentPosition: firstConnection")
            self.__restorePosition = copy.deepcopy(self.__currentPosition)
            self.__firstConnection = False

    @pyqtSlot(object)
    def calibrateOffsetsApplied(self, params=None):
        try:
            offsets = params["offsets"]
        except:
            offsets = None
        try:
            __continue = params["continue"]
        except:
            __continue = True
        self.resumeAutoToolAlignmentButton.setDisabled(True)
        self.resumeAutoToolAlignmentButton.setVisible(False)
        self.resumeAutoToolAlignmentButton.setStyleSheet(self.styleDisabled)
        for button in self.toolButtons:
            buttonName = "toolButton_" + str(self.__activePrinter["currentTool"])
            if button.objectName() == buttonName:
                toolTip = (
                    "Fetch T"
                    + str(self.__activePrinter["currentTool"])
                    + " to current machine position."
                )
                toolTip += "<pre>"
                toolTip += "X: " + "{:>9.3f}".format(offsets["X"])
                toolTip += "<br>"
                toolTip += "Y: " + "{:>9.3f}".format(offsets["Y"])
                toolTip += "<br>"
                toolTip += "Z: " + "{:>9.3f}".format(offsets["Z"])
                toolTip += "</pre>"
                button.setToolTip(toolTip)
        if __continue is True:
            toolCalibrationTime = np.around(time.time() - self.toolTime, 1)
            successMsg = (
                "Tool "
                + str(self.__activePrinter["currentTool"])
                + ": (X"
                + str(offsets["X"])
                + ", Y"
                + str(offsets["Y"])
                + ", Z"
                + str(offsets["Z"])
                + ") -- ["
                + str(toolCalibrationTime)
                + "s]."
            )
            self.updateStatusbarMessage(successMsg)
            _logger.info(successMsg)
            self.state = 200
            self.retries = 0
            self.__stateAutoNozzleAlignment = True
            self.__stateOverrideManualNozzleAlignment = False
            self.toggleNozzleAutoDetectionSignal.emit(True)
            self.calibrateTools(self.workingToolset)
        else:
            successMsg = (
                "Tool "
                + str(self.__activePrinter["currentTool"])
                + ": (X"
                + str(offsets["X"])
                + ", Y"
                + str(offsets["Y"])
                + ", Z"
                + str(offsets["Z"])
                + ")."
            )
            self.updateStatusbarMessage(successMsg)
            _logger.info(successMsg)

    def saveOffsets(self):
        self.saveToFirmwareSignal.emit()
        _logger.info("Offsets saved to firmware.")

    ########################################################################### Interface with Settings Dialog
    def displayPreferences(self, event=None, newPrinterFlag=False):
        _logger.debug("*** calling App.displayPreferences")
        # check if we already have a printer manager thread, and start it
        try:
            if self.printerThread.isRunning() is False:
                self.createPrinterManagerThread(announce=False)
        except:
            self.createPrinterManagerThread(announce=False)
        # Set up settings window
        try:
            self.settingsDialog = SettingsDialog(
                parent=self,
                newPrinter=newPrinterFlag,
                geometry=self.__settingsGeometry,
                settings=self.__userSettings,
                firmwareList=self.__firmwareList,
                cameraProperties=self.__activeCamera,
            )
            # # Signals
            # self.settingsDialog.settingsAlignmentPollSignal.connect()
            # self.settingsDialog.settingsChangeVideoSrcSignal.connect()
            # self.settingsDialog.settingsRequestCameraProperties.connect()
            # self.settingsDialog.settingsRequestImageProperties.connect()
            self.settingsDialog.settingsResetImageSignal.connect(
                self.relayResetCameraDefaults
            )
            self.settingsDialog.settingsSetImagePropertiesSignal.connect(
                self.relayImageParameters
            )
            self.settingsDialog.settingsUpdateSignal.connect(self.updateSettings)
            self.settingsDialog.settingsStatusbarSignal.connect(
                self.updateStatusbarMessage
            )
            self.settingsDialog.settingsGeometrySignal.connect(
                self.saveSettingsGeometry
            )
            self.settingsDialog.rejected.connect(self.settingsDialog.deleteLater)
            self.settingsDialog.accepted.connect(self.settingsDialog.deleteLater)
            self.settingsDialog.settingsNewPrinter.connect(self.saveNewPrinter)

        except:
            errorMsg = "Cannot start settings dialog."
            _logger.exception(errorMsg)
            return
        # self.settingsDialog.update_settings.connect(self.updateSettings)
        self.settingsDialog.exec()

        _logger.debug("*** exiting App.displayPreferences")

    @pyqtSlot(object)
    def relayImageParameters(self, imageProperties):
        self.setImagePropertiesSignal.emit(imageProperties)

    @pyqtSlot()
    def relayResetCameraDefaults(self):
        self.resetImageSignal.emit()

    @pyqtSlot(object)
    def updateSettings(self, settingOptions):
        _logger.debug("*** calling App.updateSettings")
        self.__userSettings = settingOptions
        self.saveUserSettings()
        _logger.debug("*** exiting App.updateSettings")

    @pyqtSlot(object)
    def saveNewPrinter(self, newSettingsOptions):
        self.__userSettings = newSettingsOptions
        self.saveUserSettings()
        newPrinterIndex = len(newSettingsOptions["printer"]) - 1
        self.__activePrinter = newSettingsOptions["printer"][newPrinterIndex]
        self.connectSignal.emit(self.__activePrinter)

    @pyqtSlot(object)
    def saveSettingsGeometry(self, geometry):
        self.__settingsGeometry = geometry

    ########################################################################### Utilities
    def sanitizeURL(self, inputString="http://localhost"):
        _logger.debug("*** calling App.sanitizeURL")
        _errCode = 0
        _errMsg = ""
        _printerURL = "http://localhost"
        u = urlparse(inputString)
        if u[0] == "":
            u = u._replace(scheme="http")
        scheme = u[0]
        if scheme.lower() not in ["http", "https"]:
            _errCode = 1
            _errMsg = "Invalid scheme. Please only use http/https connections."
        else:
            if u.netloc == "":
                _printerURL = u.scheme + "://" + u.path
            else:
                _printerURL = u.geturl()
        _logger.debug("Sanitized " + inputString + " to address: " + _printerURL)
        _logger.debug("*** exiting App.sanitizeURL")
        return (_errCode, _errMsg, _printerURL)

    def saveUserSettings(self):
        # save user settings.json
        _logger.debug("*** calling App.saveUserSettings")
        try:
            # get default camera from user settings
            cameraSet = False
            # new_video_src = 0
            # for camera in self.__userSettings['camera']:
            #     try:
            #         if(camera['default'] == 1 and cameraSet is False):
            #             # if new default, switch feed
            #             if(self._videoSrc != new_video_src):
            #                 new_video_src = camera['video_src']
            #                 self.video_thread.changeVideoSrc(newSrc=new_video_src)
            #                 self._videoSrc = new_video_src
            #             cameraSet = True
            #             continue
            #         elif(cameraSet):
            #             # already have a default, unset other entries
            #             camera['default'] = 0
            #     except KeyError:
            #         # No default camera defined, add key
            #         camera['default'] = 0
            #         continue
            # check if there are no cameras set as default
            if cameraSet is False:
                # Set first camera entry to be the default source
                self.__userSettings["camera"][0]["default"] = 1
                # try:
                #     # activate default camera feed
                #     self.video_thread.changeVideoSrc(newSrc=new_video_src)
                #     self._videoSrc = new_video_src
                # except:
                #     _logger.critical('Cannot load default camera source.')
            # Save settings to file
            with open("./config/settings.json", "w") as outputfile:
                json.dump(self.__userSettings, outputfile)

            _logger.info("User preferences saved to settings.json")
            self.updateStatusbarMessage("User preferences saved to settings.json")
            self.statusBar.setStyleSheet("")
        except Exception as e1:
            _logger.error("Error saving user settings file." + str(e1))
            self.statusBar.showMessage("Error saving user settings file.")
            self.statusBar.setStyleSheet(self.styleRed)
        _logger.debug("*** exiting App.saveUserSettings")

    def getDistance(self, x1, y1, x0, y0):
        _logger.debug("*** calling CalibrateNozzles.getDistance")
        x1_float = float(x1)
        x0_float = float(x0)
        y1_float = float(y1)
        y0_float = float(y0)
        x_dist = (x1_float - x0_float) ** 2
        y_dist = (y1_float - y0_float) ** 2
        retVal = np.sqrt((x_dist + y_dist))
        returnVal = np.around(retVal, 3)
        _logger.debug("*** exiting CalibrateNozzles.getDistance")
        return returnVal

    def normalize_coords(self, coords):
        xdim, ydim = self._cameraWidth, self._cameraHeight
        returnValue = (coords[0] / xdim - 0.5, coords[1] / ydim - 0.5)
        return returnValue

    def least_square_mapping(self, calibration_points):
        # Compute a 2x2 map from displacement vectors in screen space to real space.
        n = len(calibration_points)
        real_coords, pixel_coords = np.empty((n, 2)), np.empty((n, 2))
        for i, (r, p) in enumerate(calibration_points):
            real_coords[i] = r
            pixel_coords[i] = p
        x, y = pixel_coords[:, 0], pixel_coords[:, 1]
        A = np.vstack([x**2, y**2, x * y, x, y, np.ones(n)]).T
        transform = np.linalg.lstsq(A, real_coords, rcond=None)
        return transform[0], transform[1].mean()

    def toggleCrosshair(self):
        if (
            self.__stateAutoCPCapture is False
            and self.__stateAutoNozzleAlignment is False
            and self.__stateEndstopAutoCalibrate is False
        ):
            if self.__displayCrosshair is False:
                self.crosshairDisplayButton.setChecked(True)
                self.crosshairDisplayButton.setStyleSheet(self.styleOrange)
                self.__displayCrosshair = True
                self.toggleNozzleDetectionSignal.emit(True)
                self.toggleDetectionSignal.emit(True)
                self.__displayCrosshair = True
            else:
                self.crosshairDisplayButton.setChecked(False)
                self.crosshairDisplayButton.setStyleSheet(self.styleBlue)
                self.__displayCrosshair = False
                self.toggleNozzleDetectionSignal.emit(False)
                self.toggleDetectionSignal.emit(False)
                self.__displayCrosshair = False

    ########################################################################### Close application handler
    def closeEvent(self, event):
        _logger.debug("*** calling App.closeEvent")
        self.stateExiting()
        try:
            _logger.info("Closing TAMV..")
            self.statusBar.showMessage("Shutting down TAMV..")
            self.repaint()
            try:
                self.detectionThread.quit()
                self.detectionThread.wait(self.__detectionManagerThreadWaitTime)
            except:
                pass
            try:
                self.printerThread.quit()
                self.printerThread.wait(self.__printerManagerThreadWaitTime)
            except:
                pass
        except Exception:
            _logger.critical("Close event error: \n" + traceback.format_exc())
        # Output farewell message
        print()
        print("Thank you for using TAMV!")
        print("Check out www.jubilee3d.com")
        _logger.debug("*** exiting App.closeEvent")
        super(App, self).closeEvent(event)

    ########################################################################### First run setups
    def show(self):
        self.createDetectionManagerThread()
        self.createPrinterManagerThread()
        _logger.info("Initialization complete.")
        # Output welcome message
        print()
        print("  Welcome to TAMV!")
        print()
        super().show()

    def startModules(self):
        self.detectionThread.start(priority=QThread.TimeCriticalPriority)
        self.announceSignal.emit(False)


if __name__ == "__main__":
    ### Setup OS options
    # os.putenv("QT_LOGGING_RULES","qt5ct.debug=true")
    os.putenv("OPENCV_VIDEOIO_DEBUG", "0")
    # os.putenv("OPENCV_VIDEOIO_PRIORITY_LIST", "DSHOW,FFMPEG,GSTREAMER")
    ### Setup argmument parser
    parser = argparse.ArgumentParser(
        description="Program to allign multiple tools on Duet/klipper based printers, using machine vision.",
        allow_abbrev=False,
    )
    parser.add_argument(
        "-d", "--debug", action="store_true", help="Enable debug output to terminal"
    )
    # Execute argument parser
    args = vars(parser.parse_args())

    ### Setup logging
    _logger = logging.getLogger("TAMV")
    _logger.setLevel(logging.DEBUG)
    ### # file handler logging
    fileFormatter = logging.Formatter(
        "%(asctime)s --- %(levelname)s --- M:%(name)s --- T:%(threadName)s --- F:%(funcName)s --- L:%(lineno)d --- %(message)s"
    )
    # migrate logs to /log path
    try:
        os.makedirs("./log", exist_ok=True)
    except:
        print()
        print('Cannot create "./log folder.')
        print("Please create this folder manually and restart TAMV")
        raise SystemExit("Cannot retrieve log path.")
    if os.path.exists("./TAMV.log"):
        if os.path.exists("./log/TAMV.log"):
            print()
            print("Deleting old log file ./TAMV.log..")
            try:
                os.remove("./TAMV.log")
            except:
                print('Cannot delete old log file "./TAMV.log", ignoring it..')
                print('Log file now located in "./log/TAMV.log"')
        else:
            try:
                print()
                print('Moving log file to "./log/TAMV.log"..')
                os.replace("./TAMV.log", "./log/TAMV.log")
            except:
                print("Unknown OS error while moving log file to new folder.")
                print('Please move "./TAMV.log" to "./log/TAMV.log" and restart TAMV.')
                raise SystemExit("Cannot move log file.")
    fh = RotatingFileHandler("./log/TAMV.log", backupCount=1, maxBytes=1000000)
    if args["debug"]:
        fh.setLevel(logging.DEBUG)
    else:
        fh.setLevel(logging.INFO)
    fh.setFormatter(fileFormatter)
    _logger.addHandler(fh)
    ### # console handler logging
    consoleFormatter = logging.Formatter(fmt="%(levelname)-9s: %(message)s")
    ch = logging.StreamHandler()
    if args["debug"]:
        ch.setLevel(logging.DEBUG)
    else:
        ch.setLevel(logging.INFO)
    ch.setFormatter(consoleFormatter)
    _logger.addHandler(ch)

    ### # log startup messages
    print()
    _logger.warning(
        "This is an alpha release. Always use only when standing next to your machine and ready to hit EMERGENCY STOP."
    )
    print()

    ### start GUI application
    app = QApplication(sys.argv)
    a = App()
    a.show()
    t = threading.Thread(target=a.startModules)
    t.start()
    sys.exit(app.exec())