def __init__(self, log_file, windows_title, percentage_pattern):
        super(ProgressMonitor, self).__init__()

        self.setGeometry(50, 50, 500, 100)
        self.setWindowTitle(windows_title)
        self.setWindowIcon(QtGui.QIcon("pythonlogo.png"))

        closeAction = QAction("close", self)
        closeAction.setShortcut("Ctrl+Q")
        closeAction.setStatusTip("close this window")
        closeAction.triggered.connect(self.close_application)

        self.polling_interval_in_seconds = 2
        self.elapsed_time = 0.0
        self.elapsed_time_label = QLabel()
        self.elapsed_time_label.setText("elapsed time: 0 second")

        self.progress_bar = QProgressBar(self)
        # self.progress_bar.resize(400, 25)
        # self.progress_bar.setGeometry(200, 50, 250, 20)

        self.progress = 0.0  #  100 as completion
        self.last_line_number = 0
        self.percentage_pattern = percentage_pattern

        killbtn = QPushButton("Interrupt", self)
        killbtn.clicked.connect(self.interrupt_application)

        btn = QPushButton("Quit", self)
        btn.clicked.connect(self.close_application)
        btn.resize(btn.minimumSizeHint())

        hbox = QHBoxLayout()
        hbox.addWidget(killbtn)
        hbox.addStretch()
        hbox.addWidget(btn)

        vbox = QVBoxLayout()
        vbox.addWidget(self.elapsed_time_label)
        vbox.addWidget(self.progress_bar)
        vbox.addLayout(hbox)

        widget = QWidget(self)
        widget.setLayout(vbox)
        self.setCentralWidget(widget)
        self.setup_monitor(log_file)
Пример #2
0
class MainWindow(QMainWindow):
    def __init__(self, parent=None):
        super(MainWindow, self).__init__(parent)
        self.__setupUI()

    def __setupUI(self):
        self.setWindowTitle('Home')
        self.evAlgorithmButton = QPushButton('EA', self)
        self.evAlgorithmButton.resize(self.evAlgorithmButton.sizeHint())

        self.hillClimbButton = QPushButton('HC', self)
        self.hillClimbButton.resize(self.hillClimbButton.sizeHint())

        self.particleSwarmButton = QPushButton('PSO')
        self.particleSwarmButton.resize(self.particleSwarmButton.sizeHint())

        self.horizontalBox = QHBoxLayout()
        self.horizontalBox.addStretch(1)
        self.horizontalBox.addWidget(self.evAlgorithmButton)
        self.horizontalBox.addWidget(self.hillClimbButton)
        self.horizontalBox.addWidget(self.particleSwarmButton)

        self.verticalBox = QVBoxLayout()
        self.verticalBox.addStretch(1)
        self.verticalBox.addLayout(self.horizontalBox)
        self.setCentralWidget(QWidget())
        self.centralWidget().setLayout(self.verticalBox)

        self.evAlgorithmButton.clicked.connect(self.__evAlgorithmButtonClicked)
        self.hillClimbButton.clicked.connect(self.__hillClimbButtonClicked)
        self.particleSwarmButton.clicked.connect(
            self.__particleSwarmButtonClicked)

        self.evolutionaryAlgorithmWindow = EvolutionaryAlgorithmWindow(self)
        self.hillClimbingAlgorithmWindow = HillClimbingAlgorithmWindow(self)
        self.particleSwarmAlgorithmWindow = ParticleSwarmAlgorithmWindow(self)

    def __evAlgorithmButtonClicked(self):
        self.evolutionaryAlgorithmWindow.show()

    def __hillClimbButtonClicked(self):
        self.hillClimbingAlgorithmWindow.show()

    def __particleSwarmButtonClicked(self):
        self.particleSwarmAlgorithmWindow.show()
class ParticleSwarmAlgorithmWindow(QMainWindow):
    def __init__(self, parent=None):
        super(ParticleSwarmAlgorithmWindow, self).__init__(parent)
        self.__setupUI()
        self.__algoThreaded = PSOThreaded(1, 1, 1, 1, 1, 1, 1, 1, 1)
        self.__algoThreaded.signal.connect(self.status)
        self.__thread = PSOStats('data\\pso.in')
        self.__thread.signal.connect(self.received)

    def __setupUI(self):
        self.setWindowTitle('PSO')
        self.solutionButton = QPushButton('Solution', self)
        self.solutionButton.resize(self.solutionButton.sizeHint())
        self.solutionButton.clicked.connect(self.__solutionButtonClicked)

        self.stopSolutionButton = QPushButton('Stop solution', self)
        self.stopSolutionButton.resize(self.stopSolutionButton.sizeHint())
        self.stopSolutionButton.clicked.connect(self.__stopSolution)
        self.stopSolutionButton.setEnabled(False)

        self.statsButton = QPushButton('Statistics', self)
        self.statsButton.resize(self.statsButton.sizeHint())
        self.statsButton.clicked.connect(self.__statsButtonClicked)

        self.stopStatsButton = QPushButton('Stop stats', self)
        self.stopStatsButton.resize(self.stopStatsButton.sizeHint())
        self.stopStatsButton.clicked.connect(self.__stopStats)
        self.stopStatsButton.setEnabled(False)

        self.horizontalBox = QHBoxLayout()
        self.horizontalBox.addStretch(1)
        self.horizontalBox.addWidget(self.solutionButton)
        self.horizontalBox.addWidget(self.stopSolutionButton)
        self.horizontalBox.addWidget(self.statsButton)
        self.horizontalBox.addWidget(self.stopStatsButton)

        individualSizeBox = QHBoxLayout()
        label = QLabel("pop size:")
        self.problemSizeInput = QLineEdit()
        individualSizeBox.addWidget(label)
        individualSizeBox.addWidget(self.problemSizeInput)

        particleNoBox = QHBoxLayout()
        particleLabel = QLabel("No of particles (n):")
        self.particleNoInput = QLineEdit()
        particleNoBox.addWidget(particleLabel)
        particleNoBox.addWidget(self.particleNoInput)

        inertiaCoefBox = QHBoxLayout()
        inertiaLabel = QLabel("w:")
        self.inertiaInput = QLineEdit()
        inertiaCoefBox.addWidget(inertiaLabel)
        inertiaCoefBox.addWidget(self.inertiaInput)

        cognitiveCoefBox = QHBoxLayout()
        cognitiveLabel = QLabel("c1:")
        self.cognitiveInput = QLineEdit()
        cognitiveCoefBox.addWidget(cognitiveLabel)
        cognitiveCoefBox.addWidget(self.cognitiveInput)

        socialLearnBox = QHBoxLayout()
        socialLearnLabel = QLabel("c2:")
        self.socialLearnInput = QLineEdit()
        socialLearnBox.addWidget(socialLearnLabel)
        socialLearnBox.addWidget(self.socialLearnInput)

        neighbourhoodSizeBox = QHBoxLayout()
        neighbourhoodLabel = QLabel("neighbourhood size:")
        self.neighbourhoodInput = QLineEdit()
        neighbourhoodSizeBox.addWidget(neighbourhoodLabel)
        neighbourhoodSizeBox.addWidget(self.neighbourhoodInput)

        vMinSizeBox = QHBoxLayout()
        vMinLabel = QLabel("vmin:")
        self.vMinInput = QLineEdit()
        vMinSizeBox.addWidget(vMinLabel)
        vMinSizeBox.addWidget(self.vMinInput)

        vMaxSizeBox = QHBoxLayout()
        vMaxLabel = QLabel("vmax:")
        self.vMaxInput = QLineEdit()
        vMaxSizeBox.addWidget(vMaxLabel)
        vMaxSizeBox.addWidget(self.vMaxInput)

        gensBox = QHBoxLayout()
        gensLabel = QLabel("iterations:")
        self.numberOfGenerationsInput = QLineEdit()
        gensBox.addWidget(gensLabel)
        gensBox.addWidget(self.numberOfGenerationsInput)

        self.solutionLabel = QLabel()
        self.statsLabel = QLabel()
        self.verticalBox = QVBoxLayout()
        self.verticalBox.addStretch(1)
        self.verticalBox.addLayout(individualSizeBox)
        self.verticalBox.addLayout(particleNoBox)
        self.verticalBox.addLayout(inertiaCoefBox)
        self.verticalBox.addLayout(cognitiveCoefBox)
        self.verticalBox.addLayout(socialLearnBox)
        self.verticalBox.addLayout(neighbourhoodSizeBox)
        self.verticalBox.addLayout(vMinSizeBox)
        self.verticalBox.addLayout(vMaxSizeBox)
        self.verticalBox.addLayout(gensBox)
        self.verticalBox.addWidget(self.solutionLabel)
        self.verticalBox.addWidget(self.statsLabel)
        self.verticalBox.addLayout(self.horizontalBox)
        self.setCentralWidget(QWidget())
        self.centralWidget().setLayout(self.verticalBox)

    def __solutionButtonClicked(self):
        n = int(self.problemSizeInput.text())
        particleSize = int(self.particleNoInput.text())
        w = float(self.inertiaInput.text())
        c1 = float(self.cognitiveInput.text())
        c2 = float(self.socialLearnInput.text())
        neighbourhoodSize = int(self.neighbourhoodInput.text())
        iterations = int(self.numberOfGenerationsInput.text())
        vmin = int(self.vMinInput.text())
        vmax = int(self.vMaxInput.text())
        self.__algoThreaded = PSOThreaded(n, particleSize, w, c1, c2, vmin,
                                          vmax, neighbourhoodSize, iterations)
        self.__algoThreaded.signal.connect(self.status)
        self.__algoThreaded.start()
        self.stopSolutionButton.setEnabled(True)
        self.solutionButton.setEnabled(False)

    def status(self, data):
        if len(data) == 3:
            self.solutionButton.setEnabled(True)
            self.solutionLabel.setText("Solution:\n" + str(data[0]) +
                                       "\nFitness:" + str(data[1]))
        else:
            print("[PSO]Step: " + str(data[1]) + " Best fitness so far:" +
                  str(data[0]))

    def __stopSolution(self):
        self.__algoThreaded.terminate()
        self.stopSolutionButton.setEnabled(False)
        self.solutionButton.setEnabled(True)

    def __statsButtonClicked(self):
        self.statsButton.setEnabled(False)
        self.stopStatsButton.setEnabled(True)
        self.__thread.start()

    def __stopStats(self):
        self.__thread.terminate()
        self.statsButton.setEnabled(True)
        self.stopStatsButton.setEnabled(False)

    def received(self, data):
        if len(data) == 3:
            self.statsButton.setEnabled(True)
            self.stopStatsButton.setEnabled(False)
            self.statsLabel.setText("Std dev: " + str(data[0]) + "\nMean:" +
                                    str(data[1]))
            plt.plot(data[2])
            plt.show()
        else:
            print("[PSO]Step: " + str(data[1]) + " Best fitness so far:" +
                  str(data[0]))
Пример #4
0
if __name__ == '__main__':
    import sys
    from qtpy.QtCore import QTimer
    from qtpy.QtWidgets import QVBoxLayout, QPushButton
    from numpy.random import randn
    app = QApplication(sys.argv)
    meter = Speedometer('Speedometer', 'Km/h', 0, 100)
    steps = 60
    coef = 90 / sum([1 / i for i in range(1, steps + 1)])
    global timer
    timer = QTimer()
    timer.setInterval(20)
    global status
    status = 'off'
    startbutton = QPushButton('Start')
    startbutton.resize(150, 80)
    anim_start = QPropertyAnimation(meter, b"value")
    anim_start.setDuration(500)
    anim_start.setStartValue(0)
    anim_start.setEndValue(80)
    anim_start.finished.connect(timer.start)

    def random_speed_jitter():
        # print('hello',meter.speed)
        step = randn() / 10
        if ((meter.speed + step) >= 100) or ((meter.speed + step) <= 80):
            step = step * (-1)
        meter.setSpeed(meter.speed + step)

    def swap_status():
        global status
Пример #5
0
    def __init__(self, parent, spectra):
        super(ZeroLossPeakWidget, self).__init__("Zero loss peak", parent)

        self.spectra = spectra

        main_widget = QWidget()
        main_layout = QVBoxLayout()
        main_widget.setLayout(main_layout)

        self.setObjectName("zero_loss_peak_dock")
        self.setAllowedAreas(Qt.AllDockWidgetAreas)

        analyze_button = QPushButton("Analyze", self)
        analyze_button.setToolTip('Find and analyze zero loss peak')
        analyze_button.resize(analyze_button.sizeHint())
        analyze_button.clicked.connect(self.analyze_zlp)
        main_layout.addWidget(analyze_button)

        results_groupbox = QGroupBox("Analyze results")
        results_layout = QGridLayout()
        label_title_position = QLabel("Position (eV): ")
        self.label_value_position = QLabel("")
        results_layout.addWidget(label_title_position, 0, 0)
        results_layout.addWidget(self.label_value_position, 0, 1)

        label_title_fwhm = QLabel("FWHM (eV): ")
        self.label_value_fwhm = QLabel("")
        results_layout.addWidget(label_title_fwhm, 1, 0)
        results_layout.addWidget(self.label_value_fwhm, 1, 1)

        results_groupbox.setLayout(results_layout)
        main_layout.addWidget(results_groupbox)
        main_layout.addStretch(1)

        fit_button = QPushButton("Fit", self)
        fit_button.setToolTip('Find and fit zero loss peak')
        fit_button.resize(fit_button.sizeHint())
        fit_button.clicked.connect(self.fit_zlp)
        main_layout.addWidget(fit_button)

        results_fit_groupbox = QGroupBox("Fit results")
        results_fit_layout = QGridLayout()

        label_title_position = QLabel("Position (eV): ")
        self.label_value_fit_position = QLabel("")
        results_fit_layout.addWidget(label_title_position, 0, 0)
        results_fit_layout.addWidget(self.label_value_fit_position, 0, 1)

        label_title_fwhm = QLabel("FWHM (eV): ")
        self.label_value_fit_fwhm = QLabel("")
        results_fit_layout.addWidget(label_title_fwhm, 1, 0)
        results_fit_layout.addWidget(self.label_value_fit_fwhm, 1, 1)

        label_title_sigma = QLabel("sigma (eV): ")
        self.label_value_fit_sigma = QLabel("")
        results_fit_layout.addWidget(label_title_sigma, 2, 0)
        results_fit_layout.addWidget(self.label_value_fit_sigma, 2, 1)

        label_title_gamma = QLabel("gamma (eV): ")
        self.label_value_fit_gamma = QLabel("")
        results_fit_layout.addWidget(label_title_gamma, 3, 0)
        results_fit_layout.addWidget(self.label_value_fit_gamma, 3, 1)

        label_title_area = QLabel("area: ")
        self.label_value_fit_area = QLabel("")
        results_fit_layout.addWidget(label_title_area, 4, 0)
        results_fit_layout.addWidget(self.label_value_fit_area, 4, 1)

        label_title_height = QLabel("height: ")
        self.label_value_fit_height = QLabel("")
        results_fit_layout.addWidget(label_title_height, 5, 0)
        results_fit_layout.addWidget(self.label_value_fit_height, 5, 1)

        results_fit_groupbox.setLayout(results_fit_layout)

        main_layout.addWidget(results_fit_groupbox)
        main_layout.addStretch(1)

        self.setWidget(main_widget)

        self.setVisible(False)
        print(self.objectName())
class EvolutionaryAlgorithmWindow(QMainWindow):
    def __init__(self, parent=None):
        super(EvolutionaryAlgorithmWindow, self).__init__(parent)
        self.__setupUI()
        self.__algoThreaded = EAThreaded(1,1,1,1,1)
        self.__algoThreaded.signal.connect(self.status)
        self.__thread = EAStats('data\\ea.in')
        self.__thread.signal.connect(self.received)
        
    def __setupUI(self):
        self.setWindowTitle('EA')
        self.solutionButton = QPushButton('Solution', self)
        self.solutionButton.resize(self.solutionButton.sizeHint())
        self.solutionButton.clicked.connect(self.__solutionButtonClicked)
        
        self.stopSolutionButton = QPushButton('Stop solution', self)
        self.stopSolutionButton.resize(self.stopSolutionButton.sizeHint())
        self.stopSolutionButton.clicked.connect(self.__stopSolution)
        self.stopSolutionButton.setEnabled(False)
        
        self.statsButton = QPushButton('Statistics', self)
        self.statsButton.resize(self.statsButton.sizeHint())
        self.statsButton.clicked.connect(self.__statsButtonClicked)
        
        self.stopStatsButton = QPushButton('Stop stats', self)
        self.stopStatsButton.resize(self.stopStatsButton.sizeHint())
        self.stopStatsButton.clicked.connect(self.__stopStats)
        self.stopStatsButton.setEnabled(False)
        
        self.horizontalBox = QHBoxLayout()
        self.horizontalBox.addStretch(1)
        self.horizontalBox.addWidget(self.solutionButton)
        self.horizontalBox.addWidget(self.stopSolutionButton)
        self.horizontalBox.addWidget(self.statsButton)
        self.horizontalBox.addWidget(self.stopStatsButton)
        
        individualSizeBox = QHBoxLayout()
        label = QLabel("individual size:")
        self.problemSizeInput = QLineEdit()
        individualSizeBox.addWidget(label)
        individualSizeBox.addWidget(self.problemSizeInput)
        
        popSizeBox = QHBoxLayout()
        popSizeLabel = QLabel("Population size:")
        self.populationSizeInput = QLineEdit()
        popSizeBox.addWidget(popSizeLabel)
        popSizeBox.addWidget(self.populationSizeInput)
        
        mutationsBox = QHBoxLayout()
        mutationsLabel = QLabel("Mutations probability:")
        self.mutationProbabilityInput = QLineEdit()
        mutationsBox.addWidget(mutationsLabel)
        mutationsBox.addWidget(self.mutationProbabilityInput)
        
        crossoverBox = QHBoxLayout()
        crossoverLabel = QLabel("Crossover probability:")
        self.crossoverProbabilityInput = QLineEdit()
        crossoverBox.addWidget(crossoverLabel)
        crossoverBox.addWidget(self.crossoverProbabilityInput)
        
        gensBox = QHBoxLayout()
        gensLabel = QLabel("Number of generations:")
        self.numberOfGenerationsInput = QLineEdit()
        gensBox.addWidget(gensLabel)
        gensBox.addWidget(self.numberOfGenerationsInput)
        
        self.solutionLabel = QLabel()
        self.statsLabel = QLabel()
        self.verticalBox = QVBoxLayout()
        self.verticalBox.addStretch(1)
        self.verticalBox.addLayout(individualSizeBox)
        self.verticalBox.addLayout(popSizeBox)
        self.verticalBox.addLayout(mutationsBox)
        self.verticalBox.addLayout(crossoverBox)
        self.verticalBox.addLayout(gensBox)
        self.verticalBox.addWidget(self.solutionLabel)
        self.verticalBox.addWidget(self.statsLabel)
        self.verticalBox.addLayout(self.horizontalBox)
        self.setCentralWidget(QWidget())
        self.centralWidget().setLayout(self.verticalBox)
    
    def __solutionButtonClicked(self):
        self.__algoThreaded = EAThreaded(int(self.numberOfGenerationsInput.text()), int(self.problemSizeInput.text()), int(self.populationSizeInput.text()), float(self.crossoverProbabilityInput.text()), float(self.mutationProbabilityInput.text()))
        self.__algoThreaded.signal.connect(self.status)
        self.__algoThreaded.start()
        self.stopSolutionButton.setEnabled(True)
        self.solutionButton.setEnabled(False)
    
    def status(self, data):
        if len(data)==3:
            self.solutionButton.setEnabled(True)
            self.solutionLabel.setText("Solution:\n" + str(data[0]) + "\nFitness:" + str(data[1]))
        else: 
            print("[EA]Step: " + str(data[1]) + " Best fitness so far:" + str(data[0]))
   
    def __stopSolution(self):
        self.__algoThreaded.terminate()
        self.stopSolutionButton.setEnabled(False)
        self.solutionButton.setEnabled(True)
    
    def __statsButtonClicked(self):
        self.statsButton.setEnabled(False)
        self.stopStatsButton.setEnabled(True)
        self.__thread.start()
        
    def __stopStats(self):
        self.__thread.terminate()
        self.statsButton.setEnabled(True)
        self.stopStatsButton.setEnabled(False)
        
    def received(self, data):
        if len(data)==3:
            self.statsButton.setEnabled(True)
            self.stopStatsButton.setEnabled(False)    
            self.statsLabel.setText("Std dev: " + str(data[0]) + "\nMean:" + str(data[1]))
            plt.plot(data[2])
            plt.show()
        else: 
            print("[EA]Step: " + str(data[1]) + " Best fitness so far:" + str(data[0]))
            
Пример #7
0
class Csgogsi(QWidget):
    """
    App UI.

    Attributes
    ----------
    comcb : QComboBox
        Combo Box responsible for listing devices.
    connect_btn : QPushButton
        Button responsible for connection.
    payload_viewer_btn : QPushButton
        Button responsible to view the payload.
    refresh_btn :QPushButton
        Button responsible to refresh Serial.
    server_thread : ServerThread
        Server.

    Methods
    -------
    close_all(*args, **kwargs)
        Close everything before closing app.
    connect()
        Connect to COM.
    refresh()
        Refresh list.
    start_payload_viewer()
        Start Payload Viewer.
    stop_server()
        Stop the Server.
    stop_payload_viewer()
        Stop Payload Viewer.

    """
    def __init__(self) -> None:
        """Init UI."""
        super(Csgogsi, self).__init__()
        # Widgets
        self.server_thread = None
        self.connect_btn = QPushButton('Connect')
        self.connect_btn.clicked.connect(self.connect)

        self.comcb = QComboBox()
        list_ports_device = [port.device for port in list_ports.comports()]
        self.comcb.addItems(list_ports_device)
        if list_ports_device == []:
            self.connect_btn.setDisabled(True)
        else:
            self.connect_btn.setDisabled(False)

        self.refresh_btn = QPushButton('Refresh')
        self.refresh_btn.resize(self.refresh_btn.sizeHint())
        self.refresh_btn.clicked.connect(self.refresh)

        self.payload_viewer_btn = QPushButton('View payload')
        self.payload_viewer_btn.setDisabled(True)

        # Container
        vbox = QVBoxLayout()
        hbox = QHBoxLayout()
        vbox.addStretch(1)
        hbox.addWidget(self.comcb)
        hbox.addWidget(self.refresh_btn)
        vbox.addLayout(hbox)
        vbox.addWidget(self.payload_viewer_btn)
        vbox.addWidget(self.connect_btn)
        self.setLayout(vbox)
        # Icon
        app_icon = QIcon()
        app_icon.addFile(__dir__ + "\\data\\csgo-16.ico", QSize(16, 16))
        app_icon.addFile(__dir__ + "\\data\\csgo-20.ico", QSize(20, 20))
        app_icon.addFile(__dir__ + "\\data\\csgo-24.ico", QSize(24, 24))
        app_icon.addFile(__dir__ + "\\data\\csgo-32.ico", QSize(32, 32))
        app_icon.addFile(__dir__ + "\\data\\csgo-48.ico", QSize(48, 48))
        app_icon.addFile(__dir__ + "\\data\\csgo-64.ico", QSize(64, 64))
        app_icon.addFile(__dir__ + "\\data\\csgo-128.ico", QSize(128, 128))
        app_icon.addFile(__dir__ + "\\data\\csgo-256.ico", QSize(256, 256))
        app_icon.addFile(__dir__ + "\\data\\csgo-512.ico", QSize(512, 512))
        # Window
        self.setWindowIcon(app_icon)
        self.setWindowTitle('CSGO GSI on LCD')
        self.setWindowFlags(Qt.WindowCloseButtonHint)

        self.show()
        self.setFixedSize(self.size())

    @Slot()
    def refresh(self) -> None:
        """Refresh COM ports."""
        self.comcb.clear()
        list_ports_device = [port.device for port in list_ports.comports()]
        self.comcb.addItems(list_ports_device)
        if list_ports_device == []:
            self.connect_btn.setDisabled(True)
        else:
            self.connect_btn.setDisabled(False)

    @Slot()
    def connect(self) -> None:
        """Connect to the server."""
        # Disable buttons
        self.comcb.setDisabled(True)
        self.connect_btn.setDisabled(True)
        self.refresh_btn.setDisabled(True)
        # Server start
        if self.server_thread is None:
            self.server_thread = ServerThread(str(self.comcb.currentText()))
        self.server_thread.start()
        # Change connect button's function to "stop"
        self.connect_btn.clicked.disconnect()
        self.connect_btn.clicked.connect(self.stop_server)
        self.connect_btn.setDisabled(False)
        self.connect_btn.setText('Stop')
        # Enable payload_viewer
        self.payload_viewer_btn.clicked.connect(self.start_payload_viewer)
        self.payload_viewer_btn.setDisabled(False)

    @Slot()
    def stop_server(self) -> None:
        """Stop the server."""
        # Disable buttons
        self.payload_viewer_btn.setDisabled(True)
        # Kill the messenger and server
        self.server_thread.server.messenger.shutdown()
        if self.server_thread.server.payload_viewer is not None \
           and self.server_thread.server.payload_viewer.is_alive():
            self.server_thread.server.payload_viewer.shutdown()
            self.server_thread.server.payload_viewer = None
        self.server_thread.server.shutdown()
        self.server_thread = None
        # Change button function
        self.connect_btn.clicked.disconnect()
        self.connect_btn.clicked.connect(self.connect)
        self.connect_btn.setText('Connect')
        self.payload_viewer_btn.clicked.disconnect()
        self.payload_viewer_btn.clicked.connect(self.start_payload_viewer)
        self.payload_viewer_btn.setText('View payload')
        # Enable buttons
        self.comcb.setDisabled(False)
        self.connect_btn.setDisabled(False)
        self.refresh_btn.setDisabled(False)

    @Slot()
    def start_payload_viewer(self) -> None:
        """Start Payload Viewer."""
        # Start payload vierwer
        self.server_thread.server.payload_viewer = PayloadViewerThread()
        self.server_thread.server.payload_viewer.start()

        # Change button function
        self.payload_viewer_btn.clicked.disconnect()
        self.payload_viewer_btn.clicked.connect(self.stop_payload_viewer)
        self.payload_viewer_btn.setText('Hide payload')

    @Slot()
    def stop_payload_viewer(self) -> None:
        """Stop Payload Viewer."""
        # Stop payload viewer
        self.server_thread.server.payload_viewer.shutdown()
        self.server_thread.server.payload_viewer = None

        # Change button function
        self.payload_viewer_btn.clicked.disconnect()
        self.payload_viewer_btn.clicked.connect(self.start_payload_viewer)
        self.payload_viewer_btn.setText('View payload')

    def close_all(self, *args, **kwargs) -> None:
        """Close everything before closing app."""
        super(Csgogsi, self).closeEvent(*args, **kwargs)
        if self.server_thread is not None \
           and self.server_thread.server.messenger.is_alive():
            self.server_thread.server.messenger.shutdown()
        if self.server_thread is not None and self.server_thread.isRunning():
            self.server_thread.server.shutdown()
class HillClimbingAlgorithmWindow(QMainWindow):
    def __init__(self, parent=None):
        super(HillClimbingAlgorithmWindow, self).__init__(parent)
        self.__setupUI()
        self.__algoThreaded = HCThreaded(1)
        self.__algoThreaded.signal.connect(self.status)
        self.__thread = HCStats('data\\hc.in')
        self.__thread.signal.connect(self.received)

    def __setupUI(self):
        self.setWindowTitle('HC')
        self.solutionButton = QPushButton('Solution', self)
        self.solutionButton.resize(self.solutionButton.sizeHint())
        self.solutionButton.clicked.connect(self.__solutionButtonClicked)

        self.stopSolutionButton = QPushButton('Stop solution', self)
        self.stopSolutionButton.resize(self.stopSolutionButton.sizeHint())
        self.stopSolutionButton.clicked.connect(self.__stopSolution)
        self.stopSolutionButton.setEnabled(False)

        self.statsButton = QPushButton('Statistics', self)
        self.statsButton.resize(self.statsButton.sizeHint())
        self.statsButton.clicked.connect(self.__statsButtonClicked)

        self.stopStatsButton = QPushButton('Stop stats', self)
        self.stopStatsButton.resize(self.stopStatsButton.sizeHint())
        self.stopStatsButton.clicked.connect(self.__stopStats)
        self.stopStatsButton.setEnabled(False)

        individualSizeBox = QHBoxLayout()
        label = QLabel("individual size:")
        self.problemSizeInput = QLineEdit()
        individualSizeBox.addWidget(label)
        individualSizeBox.addWidget(self.problemSizeInput)

        self.horizontalBox = QHBoxLayout()
        self.horizontalBox.addStretch(1)
        self.horizontalBox.addLayout(individualSizeBox)
        self.horizontalBox.addWidget(self.solutionButton)
        self.horizontalBox.addWidget(self.stopSolutionButton)
        self.horizontalBox.addWidget(self.statsButton)
        self.horizontalBox.addWidget(self.stopStatsButton)

        self.solutionLabel = QLabel()
        self.statsLabel = QLabel()
        self.verticalBox = QVBoxLayout()
        self.verticalBox.addStretch(1)
        self.verticalBox.addWidget(self.solutionLabel)
        self.verticalBox.addWidget(self.statsLabel)
        self.verticalBox.addLayout(self.horizontalBox)
        self.setCentralWidget(QWidget())
        self.centralWidget().setLayout(self.verticalBox)

    def __solutionButtonClicked(self):
        self.__algoThreaded = HCThreaded(int(self.problemSizeInput.text()))
        self.__algoThreaded.signal.connect(self.status)
        self.__algoThreaded.start()
        self.stopSolutionButton.setEnabled(True)
        self.solutionButton.setEnabled(False)

    def __stopSolution(self):
        self.__algoThreaded.terminate()
        self.stopSolutionButton.setEnabled(False)
        self.solutionButton.setEnabled(True)

    def status(self, data):
        if len(data) == 3:
            self.solutionButton.setEnabled(True)
            self.solutionLabel.setText("Solution:\n" + str(data[0]) +
                                       "\nFitness:" + str(data[1]))
        else:
            print("[HC]Step: " + str(data[1]) + " Best fitness so far:" +
                  str(data[0]))

    def __statsButtonClicked(self):
        self.statsButton.setEnabled(False)
        self.stopStatsButton.setEnabled(True)
        self.__thread.start()

    def __stopStats(self):
        self.__thread.terminate()
        self.statsButton.setEnabled(True)
        self.stopStatsButton.setEnabled(False)

    def received(self, data):
        if len(data) == 3:
            self.statsButton.setEnabled(True)
            self.stopStatsButton.setEnabled(False)
            self.statsLabel.setText("Std dev: " + str(data[0]) + "\nMean:" +
                                    str(data[1]))
            plt.plot(data[2])
            plt.show()
        else:
            print("[HC]Step: " + str(data[1]) + " Best fitness so far:" +
                  str(data[0]))