# DEPLOY MAC

# sudo pyinstaller -F --windowed -p /Users/callum/callum/QuArray/scripts --add-data "/Users/callum/callum/QuArray/scripts:scripts" --add-binary "/Users/callum/Library/Application Support/pyinstaller/bincache00_py37_64bit/libopenslide.0.dylib:." --icon=scripts/icons/icon.icns QuArray.py

# Windows

# pyinstaller -F --windowed -p C:/Users/callum/QuArray/scripts --add-data "C:/Users/callum/QuArray/scripts;scripts" --icon=scripts/icons/icon.ico QuArray.py

# Linux

# pyinstaller -F -p ~/Documents/QuArray/scripts/ --add-data "scripts:scripts" QuArray.py

import qdarkgraystyle

from scripts import DABanalysis, Overlay, Cut_Application_thread

import sys

import os

from PyQt5.QtCore import pyqtSlot, Qt, pyqtSignal

from PyQt5.QtWidgets import QFileDialog

from PyQt5 import QtWidgets, QtGui

from PyQt5.QtWidgets import QApplication, QMainWindow

from PyQt5.uic import loadUi

import qimage2ndarray

import random

import numpy as np

from skimage.color import rgb2hsv

from PIL import Image

if not hasattr(sys, "_MEIPASS"):

    sys._MEIPASS = '.'  # for running locally

class MyWindow(QMainWindow):

    def __init__(self):

        super(MyWindow, self).__init__()

        loadUi(sys._MEIPASS + os.sep + "scripts" + os.sep + "MainWindow_layout.ui", self)  # for deployment

        self.statusBar()

        self.setWindowTitle('QuArray')

        self.setWindowOpacity(0.96)

        self.ndpi_exporter.clicked.connect(lambda: self.ndpi_export())

        self.trainingbutton.clicked.connect(lambda: self.dabanalysis())

        self.testingbutton.clicked.connect(lambda: self.thresh_action())

        self.overbtn.clicked.connect(lambda: self.overlay())

        self.actionNDPI_SVS_Export.triggered.connect(lambda: self.ndpi_export())

        self.actionRun_Dab_Analysis.triggered.connect(lambda: self.dabanalysis())

        self.actionSet_Thresholds.triggered.connect(lambda: self.thresh_action())

        self.actionOverlay_Figure.triggered.connect(lambda: self.overlay())

        self.saveimages = False

        self.checkBox.stateChanged.connect(self.clickbox)

        scene = QtWidgets.QGraphicsScene()

        self.pixmap = QtWidgets.QGraphicsPixmapItem()

        scene.addItem(self.pixmap)

        self.graphicsView.setScene(scene)

        self.show()

    def ndpi_export(self):  # select file(s) button 2

        self.NDPI = Cut_Application_thread.MyWindow()

        self.NDPI.show()

    def dabanalysis(self):  # select file(s) button 1

        self.statusupdate("Select path containing PNG files")

        self.path = QFileDialog.getExistingDirectory(parent=self, caption='Open file',

                                                     directory="/Users/callum/Desktop")

        if self.path:

            self.analysis = DABanalysis.DabAnalysis(path=self.path, save=self.saveimages)

            self.analysis.maxcuts.connect(self.progress.setMaximum)

            self.analysis.countChanged.connect(self.onCountChanged)

            self.analysis.info.connect(self.statusupdate)

            self.analysis.figures.connect(self.showimage)

            self.analysis.activate.connect(self.activate_input)

            if hasattr(self, "newthreshold"):

                print("Using new DAB threshold - " + str(self.newthreshold))

                self.analysis.threshold = self.newthreshold / 100

                self.analysis.start()

            else:

                self.analysis.start()

    def activate_input(self, onoff):

        self.trainingbutton.setEnabled(onoff)

        self.testingbutton.setEnabled(onoff)

        self.overbtn.setEnabled(onoff)

        self.checkBox.setEnabled(onoff)

    def statusupdate(self, message):

        self.statusbar.showMessage(message)

    def clickbox(self, state):

        if state == Qt.Checked:

            self.saveimages = True

        else:

            self.saveimages = False

    @pyqtSlot(int)

    def onCountChanged(self, value):

        self.progress.setValue(value)

    def showimage(self):

        img = qimage2ndarray.array2qimage(self.analysis.current_image, normalize=True)

        img = QtGui.QPixmap(img)

        self.pixmap.setPixmap(img)

        self.graphicsView.fitInView(self.graphicsView.sceneRect(), Qt.KeepAspectRatio)

    def thresh_action(self):  # select file(s) button 2

        self.SW = ThresholdSelectorWindow()

        self.SW.show()

        self.SW.signal.connect(self.updatethresholds)

    def updatethresholds(self, value):

        self.newthreshold = value

        self.statusupdate("threshold value updated - " + str(value))

        self.testingbutton.setStyleSheet("background-color: rgb(0,90,0)")

    def overlay(self):

        self.statusupdate("Select path - This is slow so only a few files if large")

        path = QFileDialog.getExistingDirectory(parent=self, caption='Open file',

                                                directory="/Users/callum/Desktop")

        if path:

            self.overlayfig = Overlay.Overlay(path=path)

            self.overlayfig.maxcuts.connect(self.progress.setMaximum)

            self.overlayfig.countChanged.connect(self.onCountChanged)

            self.overlayfig.info.connect(self.statusupdate)

            self.overlayfig.figures.connect(self.showimageoverlay)

            if hasattr(self, "newthreshold"):

                print("Using new DAB threshold - " + str(self.newthreshold))

                self.overlayfig.threshold = self.newthreshold / 100

                self.overlayfig.start()

            else:

                self.overlayfig.start()

    def showimageoverlay(self):

        img = qimage2ndarray.array2qimage(self.overlayfig.current_image, normalize=True)

        img = QtGui.QPixmap(img)

        self.pixmap.setPixmap(img)

        self.graphicsView.fitInView(self.graphicsView.sceneRect(), Qt.KeepAspectRatio)

class ThresholdSelectorWindow(QtWidgets.QWidget):

    signal = pyqtSignal(int)

    def __init__(self):

        super(ThresholdSelectorWindow, self).__init__()

        loadUi(sys._MEIPASS + os.sep + "scripts" + os.sep + "Threshold_selector_Layout.ui", self)

        self.slider.setSingleStep(1)

        self.slider.valueChanged[int].connect(self.sliderchange)

        self.setWindowTitle('Set DAB Thresholds')

        self.setWindowOpacity(0.96)

        # scene 1

        scene = QtWidgets.QGraphicsScene()

        self.pixmap = QtWidgets.QGraphicsPixmapItem()

        scene.addItem(self.pixmap)

        self.graphicsView.setScene(scene)

        # scene 2

        scene_2 = QtWidgets.QGraphicsScene()

        self.pixmap_2 = QtWidgets.QGraphicsPixmapItem()

        scene_2.addItem(self.pixmap_2)

        self.graphicsView_2.setScene(scene_2)

        # scene 3 - graphicsView_zoom1

        scene_3 = QtWidgets.QGraphicsScene()

        self.pixmap_3 = QtWidgets.QGraphicsPixmapItem()

        scene_3.addItem(self.pixmap_3)

        self.graphicsView_zoom1.setScene(scene_3)

        # scene 4 - graphicsView_zoom2

        scene_4 = QtWidgets.QGraphicsScene()

        self.pixmap_4 = QtWidgets.QGraphicsPixmapItem()

        scene_4.addItem(self.pixmap_4)

        self.graphicsView_zoom2.setScene(scene_4)

        self.trainingbutton.clicked.connect(lambda: self.getpath())

        self.imagebutton.clicked.connect(lambda: self.sampleimage())

        self.togglebtn.clicked.connect(lambda: self.toggle())

        self.applybtn.clicked.connect(lambda: self.apply())

        if not hasattr(self, "path"):

            self.imagebutton.setEnabled(False)

            self.togglebtn.setEnabled(False)

            self.applybtn.setEnabled(False)

            self.slider.setVisible(False)

            self.slbl.setEnabled(False)

            self.dablbl.setEnabled(False)

            self.lbl2.setEnabled(False)

        self.show()

    def getpath(self):  # select file(s) button 1

        self.path = QFileDialog.getExistingDirectory(parent=self, caption='Open file path',

                                                     directory="/Users/callum/Desktop")

        if self.path:

            self.imagebutton.setEnabled(True)

            self.togglebtn.setEnabled(True)

            self.applybtn.setEnabled(True)

            self.slider.setVisible(True)

            self.slbl.setEnabled(True)

            self.dablbl.setEnabled(True)

            self.lbl2.setEnabled(True)

            self.lbl.setText(self.path)

            self.sampleimage()  # get a sample image

    def settext(self, text):

        self.lbl2.setText(text)

        self.lbl2.repaint()

        return

    @pyqtSlot()

    def sampleimage(self):

        if hasattr(self, "path"):

            files = [f for f in os.listdir(self.path) if f.endswith(".png") and not f.endswith("Overlay.png")]

            self.randpath = files[random.randint(0, len(files) - 1)]

            self.settext(self.randpath)

            self.img = np.array(Image.open(self.path + os.sep + self.randpath))[:, :, :3]

            center = int(self.img.shape[0] / 2)

            self.zoomimg = self.img[center - 256:center + 256, center - 256:center + 256, :]

            zoomimg = qimage2ndarray.array2qimage(self.zoomimg, normalize=True)

            zoomimg = QtGui.QPixmap(zoomimg)

            self.pixmap_4.setPixmap(zoomimg)

            self.graphicsView_zoom2.fitInView(self.graphicsView_zoom2.sceneRect(), Qt.KeepAspectRatio)

            self.pixmap_3.setPixmap(zoomimg)

            self.graphicsView_zoom1.fitInView(self.graphicsView_zoom1.sceneRect(), Qt.KeepAspectRatio)

            self.img = self.img[::4, ::4]  # todo scale this better

            showim = qimage2ndarray.array2qimage(self.img, normalize=True)

            showim = QtGui.QPixmap(showim)

            self.pixmap_2.setPixmap(showim)

            self.graphicsView_2.fitInView(self.graphicsView_2.sceneRect(), Qt.KeepAspectRatio)

            # prep for analysis

            img_hsv = rgb2hsv(self.img)

            self.img_hue = img_hsv[:, :, 0]

            self.image_sat = img_hsv[:, :, 1]

            img_hsv_zoom = rgb2hsv(self.zoomimg)

            self.img_hue_sml = img_hsv_zoom[:, :, 0]

            self.image_sat_sml = img_hsv_zoom[:, :, 1]

            self.slider.setMaximum((self.image_sat.max()) * 100)

            self.slider.setMinimum((self.image_sat.min()) * 100)

            self.togimg = qimage2ndarray.array2qimage(self.img, normalize=True)

            self.togimg = QtGui.QPixmap(self.togimg)

            self.pixmap.setPixmap(self.togimg)

            self.graphicsView.fitInView(self.graphicsView.sceneRect(), Qt.KeepAspectRatio)

            return

    def resizeEvent(self, event):

        self.graphicsView.fitInView(self.graphicsView.sceneRect(), Qt.KeepAspectRatio)

        self.graphicsView_2.fitInView(self.graphicsView_2.sceneRect(), Qt.KeepAspectRatio)

        self.graphicsView_zoom1.fitInView(self.graphicsView_zoom1.sceneRect(), Qt.KeepAspectRatio)

        self.graphicsView_zoom2.fitInView(self.graphicsView_zoom2.sceneRect(), Qt.KeepAspectRatio)

        self.show()

    def sliderchange(self, value):

        if hasattr(self, "img"):

            self.slbl.setText(str(value))

            #  todo sort the poor code here

            # large image

            hue = np.logical_and(self.img_hue > 0.02, self.img_hue < 0.10)  # BROWN PIXELS BETWEEN 0.02 and 0.10

            img = np.logical_and(hue, self.image_sat > value / 100)

            img = qimage2ndarray.array2qimage(img, normalize=True)

            img = QtGui.QPixmap(img)

            self.pixmap.setPixmap(img)

            self.graphicsView.fitInView(self.graphicsView.sceneRect(), Qt.KeepAspectRatio)

            # small image

            hue = np.logical_and(self.img_hue_sml > 0.02, self.img_hue_sml < 0.10)  # BROWN PIXELS BETWEEN 0.02 and 0.10

            img = np.logical_and(hue, self.image_sat_sml > value / 100)

            img = qimage2ndarray.array2qimage(img, normalize=True)

            img = QtGui.QPixmap(img)

            self.pixmap_3.setPixmap(img)

            self.graphicsView_zoom1.fitInView(self.graphicsView_zoom1.sceneRect(), Qt.KeepAspectRatio)

    def toggle(self):

        if hasattr(self, "togimg"):

            self.pixmap.setPixmap(self.togimg)

            self.graphicsView.fitInView(self.graphicsView.sceneRect(), Qt.KeepAspectRatio)

    pyqtSlot()

    def apply(self):

        self.signal.emit(int(self.slider.value()))

if __name__ == '__main__':

    app = QApplication(sys.argv)

    window = MyWindow()

    # style sheet - https://github.com/mstuttgart/qdarkgraystyle

    app.setStyleSheet(qdarkgraystyle.load_stylesheet())

    sys.exit(app.exec_())