sad

import sys
from PySide.QtGui import *
from PySide.QtCore import *
from ui.MainWindow import Ui_MainWindow
from HistogramsWindow import HistogramsWindow
import os
import matplotlib.pyplot as plotter
from LUT import *
from PIL import Image, ImageQt
from MyImage import MyImage


class MainWindow(QMainWindow, Ui_MainWindow):
    def __init__(self):
        super(MainWindow, self).__init__()
        self.setupUi(self)
        self.show()
        self.scene_orig = QGraphicsScene()
        self.img_orig_view.setScene(self.scene_orig)
        self.scene_preview = QGraphicsScene()
        self.img_preview_view.setScene(self.scene_preview)

        self.img_orig = MyImage()
        self.img_preview = MyImage()

        self.histograms = HistogramsWindow()

        self.actionOpenImage.clicked.connect(self.open_image)
        self.actionSave.triggered.connect(self.save_image)
        self.actionOpenHistograms.triggered.connect(self.open_histograms)
        self.actionOpenBrightnessWindow.triggered.connect(self.set_brightness_handler)
        self.actionOpenEqualizationWindow.triggered.connect(self.histogram_equalization_handler)
        self.actionOpenStretchingWindow.triggered.connect(self.histogram_stretch_handler)
        self.actionOpenCustomBinarization.triggered.connect(self.custom_binarization_handler)
        self.actionOpenOtsuBinarization.triggered.connect(self.otsu_binarization_handler)
        # self.actionOpenNiblackBinarization.triggered.connect(self.niblack_binarization_handler)

    def open_image(self):
        path, _ = QFileDialog.getOpenFileName()
        img = Image.open(path)
        self.refresh_image_view(img, self.img_orig, self.scene_orig, self.img_orig_view)
        self.refresh_image_view(img, self.img_preview, self.scene_preview, self.img_preview_view)

    def save_image(self):
        path, _ = QFileDialog.getSaveFileName()
        self.img_preview.img.save(path)

    def open_histograms(self):
        self.refresh_histograms(self.img_preview.img)

    def set_brightness_handler(self):
        text, ok = QInputDialog.getInt(self, 'Input Dialog', 'b:')
        if ok:
            b = int(text)
            lut = getBrightnessLUT(b)
            img_prev = Image.eval(self.img_orig.img, applyLUT(lut))
            self.refresh_image_view(img_prev, self.img_preview, self.scene_preview, self.img_preview_view)

    def histogram_equalization_handler(self):
        if self.img_orig.img.mode in ('RGB', 'RGBA'):
            r, g, b = self.img_orig.img.split()
            r = r.point(getEqualizationLUT(r.histogram()))
            g = g.point(getEqualizationLUT(g.histogram()))
            b = b.point(getEqualizationLUT(b.histogram()))
            img_prev = Image.merge('RGB', (r, g, b))
        else:
            img_prev = self.img_orig.img.copy()
            img_prev = img_prev.point(getEqualizationLUT(img_prev.histogram()))
        self.refresh_image_view(img_prev, self.img_preview, self.scene_preview, self.img_preview_view)

    def histogram_stretch_handler(self):
        text_a, ok_a = QInputDialog.getInt(self, 'Input Dialog', 'a:')
        text_b, ok_b = QInputDialog.getInt(self, 'Input Dialog', 'b:')
        if ok_a and ok_b:
            extrema = (int(text_a), int(text_b))
        else:
            extrema = None

        if self.img_orig.img.mode in ('RGB', 'RGBA'):
            r, g, b = self.img_orig.img.split()
            r = r.point(getStretchLUT(r, extrema))
            g = g.point(getStretchLUT(g, extrema))
            b = b.point(getStretchLUT(b, extrema))
            img_prev = Image.merge('RGB', (r, g, b))
        else:
            img_prev = self.img_orig.img.copy()
            img_prev = img_prev.point(getStretchLUT(img_prev, extrema))
        self.refresh_image_view(img_prev, self.img_preview, self.scene_preview, self.img_preview_view)

    def binarize(self, treshold):
        img_prev = self.img_orig.img.convert('L')
        img_prev = img_prev.point(getBinarizationLUT(treshold))
        self.refresh_image_view(img_prev, self.img_preview, self.scene_preview, self.img_preview_view)

    def custom_binarization_handler(self):
        text, ok = QInputDialog.getInt(self, 'Input Dialog', 'Prog:')
        if ok:
            self.binarize(int(text))

    def otsu_binarization_handler(self):
        prev_img = self.img_orig.img.convert('L')
        bits = prev_img.getdata()
        n = len(bits) / 4
        hist = 256 * [0]
        for i in range(0, len(bits), 4):
            hist[bits[i]] += 1
        s = sum(hist[i] * i for i in range(256))
        w = maximum = threshold = s0 = 0
        for i in range(256):
            w += hist[i]
            if n == w:
                break
            if w != 0:
                s0 += i * hist[i]
                between = (s0 * n - s * w) ** 2 / w / (n - w)
                if between > maximum:
                    threshold = i
                    maximum = between
        print threshold
        self.binarize(threshold)

    # def niblack_binarization_handler(self):
    #     img = self.img_orig.img.copy()
    #     text, ok = QInputDialog.getInt(self, 'Input Dialog', 'rozmiar:')
    #     size = int(text)
    #     text, ok = QInputDialog.getDouble(self, 'Input Dialog', 'k:')
    #     k = float(text)
    #     colors = list(img.getdata())[::4]
    #     print colors
    #     w, h = img.size
    #     thresholds = len(colors) * [0]
    #     for i in range(len(colors)):
    #         x, y = i % w, i // w
    #         x0, y0 = x - size // 2, y - size // 2
    #         block = []
    #         for y1 in range(y0, y0 + size):
    #             for x1 in range(x0, x0 + size):
    #                 if 0 <= x1 < w and 0 <= y1 < h:
    #                     block.append(y1 * w + x1)
    #         block = list(map(lambda a: colors[a], block))
    #         m = sum(block) / len(block)
    #         d = (sum(map(lambda a: (a - m) ** 2, block)) / len(block)) ** 0.5
    #         thresholds[i] = int(m + k * d)
    #     bits = img.bits()
    #     for i, v in enumerate(thresholds):
    #         c = 0 if colors[i] <= v else 255
    #         bits[4 * i] = c
    #         bits[4 * i + 1] = c
    #         bits[4 * i + 2] = c
    #     img.putdata(bits)
    #
    #     self.refresh_image_view(img, self.img_preview, self.scene_preview, self.img_preview_view)

    def refresh_image_view(self, img, my_image, scene, view):
        my_image.img = img
        print img.mode
        my_image.data = data = img.convert('RGBA').tobytes('raw', 'RGBA')
        my_image.qt = img_qt = QImage(data, img.size[0], img.size[1], QImage.Format_ARGB32)
        my_image.pixmap = QPixmap.fromImage(img_qt)
        scene.clear()
        view.update()
        view.setTransform(QTransform())
        scene.addPixmap(my_image.pixmap)

    def refresh_histograms(self, image):
        plotter.clf()
        if image.mode in ('RGB', 'RGBA'):
            names = ('red', 'green', 'blue', 'avg')
            hist = tuple(band.getdata() for band in image.split())
            paths = tuple((os.path.join(os.path.dirname(__file__), 'tmp', name + '.png') for name in names))
            for counter, data in enumerate(tuple(zip(paths[:3], hist))):
                plotter.subplot(2, 2, counter + 1)
                plotter.hist(data[1], bins=255)
                plotter.ylabel(names[counter])
                plotter.xlim((0, 255))
                # plotter.savefig(data[0], dpi=50)
                # plotter.clf()

            avg_hist = tuple(int((r + g + b) / 3) for r, g, b in zip(*hist))
            plotter.subplot(2, 2, counter + 2)
            plotter.hist(avg_hist, bins=255)
            plotter.ylabel('avg')
            plotter.xlim((0, 255))
            # plotter.savefig(paths[3], dpi=50)
            # plotter.clf()
            plotter.show()
        else:
            hist = image.split()[0].getdata()
            path = os.path.join(os.path.dirname(__file__), 'tmp', 'gray.png')
            plotter.hist(hist)
            plotter.ylabel('gray')
            plotter.xlim((0, 255))
            # plotter.savefig(path, dpi=50)
            plotter.show()


if __name__ == '__main__':
    app = QApplication(sys.argv)
    mainWin = MainWindow()

    ret = app.exec_()
    sys.exit(ret)