opencvpyqtdip/custom/listWidgetItems.py

import numpy as np
import imutils
from PyQt5.QtCore import QSize
from PyQt5.QtGui import QIcon, QColor
from PyQt5.QtWidgets import QListWidgetItem, QPushButton
from flags import *
import cv2
import random
from PIL import Image


class MyItem(QListWidgetItem):
    def __init__(self, name=None, parent=None):
        super(MyItem, self).__init__(name, parent=parent)
        self.setIcon(QIcon('icons/color.png'))
        self.setSizeHint(QSize(60, 60))  # size

    def get_params(self):
        protected = [v for v in dir(self) if v.startswith('_') and not v.startswith('__')]
        param = {}
        for v in protected:
            param[v.replace('_', '', 1)] = self.__getattribute__(v)
        return param

    def update_params(self, param):
        for k, v in param.items():
            if '_' + k in dir(self):
                self.__setattr__('_' + k, v)


class GrayingItem(MyItem):
    def __init__(self, parent=None):
        super(GrayingItem, self).__init__(' 灰度化 ', parent=parent)
        self._mode = BGR2GRAY_COLOR

    def __call__(self, img):
        img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
        img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
        return img


class FilterItem(MyItem):

    def __init__(self, parent=None):
        super().__init__('平滑处理', parent=parent)
        self._ksize = 3
        self._kind = MEAN_FILTER
        self._sigmax = 0

    def __call__(self, img):
        if self._kind == MEAN_FILTER:
            img = cv2.blur(img, (self._ksize, self._ksize))
        elif self._kind == GAUSSIAN_FILTER:
            img = cv2.GaussianBlur(img, (self._ksize, self._ksize), self._sigmax)
        elif self._kind == MEDIAN_FILTER:
            img = cv2.medianBlur(img, self._ksize)
        return img


class MorphItem(MyItem):
    def __init__(self, parent=None):
        super().__init__(' 形态学 ', parent=parent)
        self._ksize = 3
        self._op = ERODE_MORPH_OP
        self._kshape = RECT_MORPH_SHAPE

    def __call__(self, img):
        op = MORPH_OP[self._op]
        kshape = MORPH_SHAPE[self._kshape]
        kernal = cv2.getStructuringElement(kshape, (self._ksize, self._ksize))
        img = cv2.morphologyEx(img, self._op, kernal)
        return img


class GradItem(MyItem):

    def __init__(self, parent=None):
        super().__init__('图像梯度', parent=parent)
        self._kind = SOBEL_GRAD
        self._ksize = 3
        self._dx = 1
        self._dy = 0

    def __call__(self, img):
        if self._dx == 0 and self._dy == 0 and self._kind != LAPLACIAN_GRAD:
            self.setBackground(QColor(255, 0, 0))
            self.setText('图像梯度 （无效: dx与dy不同时为0）')
        else:
            self.setBackground(QColor(200, 200, 200))
            self.setText('图像梯度')
            if self._kind == SOBEL_GRAD:
                img = cv2.Sobel(img, -1, self._dx, self._dy, self._ksize)
            elif self._kind == SCHARR_GRAD:
                img = cv2.Scharr(img, -1, self._dx, self._dy)
            elif self._kind == LAPLACIAN_GRAD:
                img = cv2.Laplacian(img, -1)
        return img


class ThresholdItem(MyItem):
    def __init__(self, parent=None):
        super().__init__('阈值处理', parent=parent)
        self._thresh = 127
        self._maxval = 255
        self._method = BINARY_THRESH_METHOD

    def __call__(self, img):
        method = THRESH_METHOD[self._method]
        img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
        img = cv2.threshold(img, self._thresh, self._thresh, method)[1]
        img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
        return img


class EdgeItem(MyItem):
    def __init__(self, parent=None):
        super(EdgeItem, self).__init__('边缘检测', parent=parent)
        self._thresh1 = 20
        self._thresh2 = 100

    def __call__(self, img):
        img = cv2.Canny(img, threshold1=self._thresh1, threshold2=self._thresh2)
        img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
        return img


class ContourItem(MyItem):
    def __init__(self, parent=None):
        super(ContourItem, self).__init__('轮廓检测', parent=parent)
        self._mode = TREE_CONTOUR_MODE
        self._method = SIMPLE_CONTOUR_METHOD
        self._bbox = NORMAL_CONTOUR

    def __call__(self, img):
        mode = CONTOUR_MODE[self._mode]
        method = CONTOUR_METHOD[self._method]
        img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        cnts, _ = cv2.findContours(img, mode, method)
        img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
        if self._bbox == RECT_CONTOUR:
            bboxs = [cv2.boundingRect(cnt) for cnt in cnts]
            print(bboxs)
            for x, y, w, h in bboxs:
                img = cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), thickness=2)
        elif self._bbox == MINRECT_CONTOUR:
            bboxs = [np.int0(cv2.boxPoints(cv2.minAreaRect(cnt))) for cnt in cnts]
            img = cv2.drawContours(img, bboxs, -1, (255, 0, 0), thickness=2)
        elif self._bbox == MINCIRCLE_CONTOUR:
            circles = [cv2.minEnclosingCircle(cnt) for cnt in cnts]
            print(circles)
            for (x, y), r in circles:
                img = cv2.circle(img, (int(x), int(y)), int(r), (255, 0, 0), thickness=2)
        elif self._bbox == NORMAL_CONTOUR:
            img = cv2.drawContours(img, cnts, -1, (255, 0, 0), thickness=2)

        return img


class EqualizeItem(MyItem):
    def __init__(self, parent=None):
        super().__init__(' 均衡化 ', parent=parent)
        self._blue = True
        self._green = True
        self._red = True

    def __call__(self, img):
        b, g, r = cv2.split(img)
        if self._blue:
            b = cv2.equalizeHist(b)
        if self._green:
            g = cv2.equalizeHist(g)
        if self._red:
            r = cv2.equalizeHist(r)
        return cv2.merge((b, g, r))


class HoughLineItem(MyItem):
    def __init__(self, parent=None):
        super(HoughLineItem, self).__init__('直线检测', parent=parent)
        self._rho = 1
        self._theta = np.pi / 180
        self._thresh = 10
        self._min_length = 20
        self._max_gap = 5

    def __call__(self, img):
        img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        lines = cv2.HoughLinesP(img, self._rho, self._theta, self._thresh, minLineLength=self._min_length,
                                maxLineGap=self._max_gap)
        img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
        if lines is None:
            return img
        for line in lines:
            for x1, y1, x2, y2 in line:
                img = cv2.line(img, (x1, y1), (x2, y2), (0, 255, 0), thickness=2)
        return img


class GammaItem(MyItem):
    def __init__(self, parent=None):
        super(GammaItem, self).__init__('伽马校正', parent=parent)
        self._gamma = 1

    def __call__(self, img):
        gamma_table = [np.power(x / 255.0, self._gamma) * 255.0 for x in range(256)]
        gamma_table = np.round(np.array(gamma_table)).astype(np.uint8)
        return cv2.LUT(img, gamma_table)

        # 重构：
        # 裁剪：


class RotateAnyItem(MyItem):  # 任意旋转
    def __init__(self, parent=None):
        super(RotateAnyItem, self).__init__('任意旋转', parent=parent)
        self._angle = 0

    def __call__(self, img):
        img = imutils.rotate_bound(img, self._angle)
        return img


class RotateLeftItem(MyItem):  # 90度旋转
    def __init__(self, parent=None):
        super(RotateLeftItem, self).__init__('向左旋转', parent=parent)

    def __call__(self, img):
        img = imutils.rotate_bound(img, -90)
        return img


class RotateRightItem(MyItem):  # 90度旋转
    def __init__(self, parent=None):
        super(RotateRightItem, self).__init__('向右旋转', parent=parent)

    def __call__(self, img):
        img = imutils.rotate_bound(img, 90)
        return img


class UpDownItem(MyItem):
    def __init__(self, parent=None):
        super(UpDownItem, self).__init__('上下翻折', parent=parent)

    def __call__(self, img):
        img = cv2.flip(img, 0)
        return img


# 光效


class ExposureItem(MyItem):
    def __init__(self, parent=None):
        super(ExposureItem, self).__init__('曝光', parent=parent)
        self._alpha = 1

    def __call__(self, img):
        blank = np.zeros(img.shape, img.dtype)
        img = cv2.addWeighted(img, self._alpha, blank, 1 - self._alpha, 0)
        return img


class LightItem(MyItem):
    def __init__(self, parent=None):
        super(LightItem, self).__init__('亮度调节', parent=parent)
        self._beta = 0

    def __call__(self, img):
        blank = np.zeros(img.shape, img.dtype)
        img = cv2.addWeighted(img, 1, blank, 0, self._beta)
        return img


class ContrastItem(MyItem):
    def __init__(self, parent=None):
        super(ContrastItem, self).__init__('对比度调节', parent=parent)
        self._alpha = 1

    def __call__(self, img):
        dst = np.ones(img.shape)
        img = np.uint8(np.clip(self._alpha * (img - 127 * dst) + 127 * dst, 0, 255))
        return img

        #  色彩：


class ColorTemperatureItem(MyItem):
    def __init__(self, parent=None):
        super(ColorTemperatureItem, self).__init__('色温调节', parent=parent)
        self._n = 50

    def __call__(self, img):
        level = self._n / 2
        # src = img.clone()
        info = img.shape
        row = info[0]
        col = info[1]
        for i in range(0, row):
            for j in range(0, col):
                (r, b, g) = img[i, j]
                rr = r - level
                bb = b - level
                gg = g + level
                if rr > 255:
                    rr = 255
                elif rr < 0:
                    rr = 0
                if bb > 255:
                    bb = 255
                elif bb < 0:
                    bb = 0
                if gg > 255:
                    gg = 255
                elif gg < 0:
                    gg = 0
                img[i, j] = (rr, bb, gg)
        return img


class HueItem(MyItem):
    def __init__(self, parent=None):
        super(HueItem, self).__init__('色调调节', parent=parent)
        self._n = 50

    def __call__(self, img):
        level = self._n / 2
        # src = img.clone()
        info = img.shape
        row = info[0]
        col = info[1]
        for i in range(0, row):
            for j in range(0, col):
                (r, b, g) = img[i, j]
                rr = r + level
                bb = b - level
                gg = g + level
                if rr > 255:
                    rr = 255
                elif rr < 0:
                    rr = 0
                if bb > 255:
                    bb = 255
                elif bb < 0:
                    bb = 0
                if gg > 255:
                    gg = 255
                elif gg < 0:
                    gg = 0
                img[i, j] = (rr, bb, gg)
        return img


class SaturationItem(MyItem):
    def __init__(self, parent=None):
        super(SaturationItem, self).__init__('饱和度调节', parent=parent)
        self._x = 0

    def __call__(self, img):
        img_t = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
        # 获取hsv
        h, s, v = cv2.split(img_t)
        # 增加饱和度 饱和度越低，越接近灰度图像
        s1 = np.clip(cv2.add(s, self._x), 0, 255)
        img = np.uint8(cv2.merge((h, s1, v)))
        img = cv2.cvtColor(img, cv2.COLOR_HSV2BGR)
        return img

        # HSL:


class HSLRedItem(MyItem):
    def __init__(self, parent=None):
        super(HSLRedItem, self).__init__('红色', parent=parent)
        self._red_param_s = 1.0
        self._red_param_v = 1.0

    def __call__(self, img):
        img_hsl = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
        info = img.shape
        height = info[0]
        width = info[1]
        value1 = self._red_param_v - 1.0
        value2 = self._red_param_s - 1.0
        for m in range(height):
            for w in range(width):
                h, s, v = img_hsl[m, w]
                b, g, r = img[m, w]
                tag = abs((int(b) - int(g)) * (int(g) - int(r)))
                if 43 < s < 255 and 46 < v < 255 and tag > 1600:
                    if 0 < h < 10 or 156 < h < 180:
                        b = (b + (b - v) * value2)
                        g = (g + (g - v) * value2)
                        r = (r + (r - v) * value2)
                        b = b + value1 * (255 - b)
                        g = g + value1 * (255 - g)
                        r = r + value1 * (255 - r)

                img[m, w] = [b, g, r]

        return img


class HSLOrangeItem(MyItem):
    def __init__(self, parent=None):
        super(HSLOrangeItem, self).__init__('橙色', parent=parent)
        self._orange_param_s = 1.0
        self._orange_param_v = 1.0

    def __call__(self, img):
        img_hsl = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
        info = img.shape
        height = info[0]
        width = info[1]
        value1 = self._orange_param_v - 1.0
        value2 = self._orange_param_s - 1.0
        for m in range(height):
            for w in range(width):
                h, s, v = img_hsl[m, w]
                b, g, r = img[m, w]
                tag = abs((int(b) - int(g)) * (int(g) - int(r)))
                if 43 < s < 255 and 46 < v < 255 and tag > 1600:
                    if 11 < h < 25:
                        b = (b + (b - v) * value2)
                        g = (g + (g - v) * value2)
                        r = (r + (r - v) * value2)
                        b = b + value1 * (255 - b)
                        g = g + value1 * (255 - g)
                        r = r + value1 * (255 - r)

                img[m, w] = [b, g, r]

        return img


class HSLYellowItem(MyItem):
    def __init__(self, parent=None):
        super(HSLYellowItem, self).__init__('黄色', parent=parent)
        self._yellow_param_s = 1.0
        self._yellow_param_v = 1.0

    def __call__(self, img):
        img_hsl = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
        info = img.shape
        height = info[0]
        width = info[1]
        value1 = self._yellow_param_v - 1.0
        value2 = self._yellow_param_s - 1.0
        for m in range(height):
            for w in range(width):
                h, s, v = img_hsl[m, w]
                b, g, r = img[m, w]
                tag = abs((int(b) - int(g)) * (int(g) - int(r)))
                if 43 < s < 255 and 46 < v < 255 and tag > 1600:
                    if 26 < h < 34:
                        b = (b + (b - v) * value2)
                        g = (g + (g - v) * value2)
                        r = (r + (r - v) * value2)
                        b = b + value1 * (255 - b)
                        g = g + value1 * (255 - g)
                        r = r + value1 * (255 - r)

                img[m, w] = [b, g, r]

        return img


class HSLGreenItem(MyItem):
    def __init__(self, parent=None):
        super(HSLGreenItem, self).__init__('绿色', parent=parent)
        self._green_param_s = 1.0
        self._green_param_v = 1.0

    def __call__(self, img):
        img_hsl = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
        info = img.shape
        height = info[0]
        width = info[1]
        value1 = self._green_param_v - 1.0
        value2 = self._green_param_s - 1.0
        for m in range(height):
            for w in range(width):
                h, s, v = img_hsl[m, w]
                b, g, r = img[m, w]
                tag = abs((int(b) - int(g)) * (int(g) - int(r)))
                if 43 < s < 255 and 46 < v < 255 and tag > 1600:
                    if 35 < h < 77:
                        b = (b + (b - v) * value2)
                        g = (g + (g - v) * value2)
                        r = (r + (r - v) * value2)
                        b = b + value1 * (255 - b)
                        g = g + value1 * (255 - g)
                        r = r + value1 * (255 - r)

                img[m, w] = [b, g, r]

        return img


class HSLCyanItem(MyItem):
    def __init__(self, parent=None):
        super(HSLCyanItem, self).__init__('青色', parent=parent)
        self._cyan_param_s = 1.0
        self._cyan_param_v = 1.0

    def __call__(self, img):
        img_hsl = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
        info = img.shape
        height = info[0]
        width = info[1]
        value1 = self._cyan_param_v - 1.0
        value2 = self._cyan_param_s - 1.0
        for m in range(height):
            for w in range(width):
                h, s, v = img_hsl[m, w]
                b, g, r = img[m, w]
                tag = abs((int(b) - int(g)) * (int(g) - int(r)))
                if 43 < s < 255 and 46 < v < 255 and tag > 1600:
                    if 78 < h < 99:
                        b = (b + (b - v) * value2)
                        g = (g + (g - v) * value2)
                        r = (r + (r - v) * value2)
                        b = b + value1 * (255 - b)
                        g = g + value1 * (255 - g)
                        r = r + value1 * (255 - r)

                img[m, w] = [b, g, r]

        return img


class HSLBlueItem(MyItem):
    def __init__(self, parent=None):
        super(HSLBlueItem, self).__init__('蓝色', parent=parent)
        self._blue_param_s = 1.0
        self._blue_param_v = 1.0

    def __call__(self, img):
        img_hsl = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
        info = img.shape
        height = info[0]
        width = info[1]
        value1 = self._blue_param_v - 1.0
        value2 = self._blue_param_s - 1.0
        for m in range(height):
            for w in range(width):
                h, s, v = img_hsl[m, w]
                b, g, r = img[m, w]
                tag = abs((int(b) - int(g)) * (int(g) - int(r)))
                if 43 < s < 255 and 46 < v < 255 and tag > 1600:
                    if 100 < h < 124:
                        b = (b + (b - v) * value2)
                        g = (g + (g - v) * value2)
                        r = (r + (r - v) * value2)
                        b = b + value1 * (255 - b)
                        g = g + value1 * (255 - g)
                        r = r + value1 * (255 - r)

                img[m, w] = [b, g, r]

        return img


class HSLPurpleItem(MyItem):
    def __init__(self, parent=None):
        super(HSLPurpleItem, self).__init__('紫色', parent=parent)
        self._purple_param_s = 1.0
        self._purple_param_v = 1.0

    def __call__(self, img):
        img_hsl = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
        info = img.shape
        height = info[0]
        width = info[1]
        value1 = self._purple_param_v - 1.0
        value2 = self._purple_param_s - 1.0
        for m in range(height):
            for w in range(width):
                h, s, v = img_hsl[m, w]
                b, g, r = img[m, w]
                tag = abs((int(b) - int(g)) * (int(g) - int(r)))
                if 43 < s < 255 and 46 < v < 255 and tag > 1600:
                    if 125 < h < 155:
                        b = (b + (b - v) * value2)
                        g = (g + (g - v) * value2)
                        r = (r + (r - v) * value2)
                        b = b + value1 * (255 - b)
                        g = g + value1 * (255 - g)
                        r = r + value1 * (255 - r)

                img[m, w] = [b, g, r]

        return img


class PixelateItem(MyItem):
    def __init__(self, parent=None):
        super(PixelateItem, self).__init__('像素化', parent=parent)
        self._size = 100

    def __call__(self, img):
        height, width = img.shape[:2]

        # Desired "pixelated" size

        w, h = (self._size, self._size)

        # Resize input to "pixelated" size

        temp = cv2.resize(img, (w, h), interpolation=cv2.INTER_LINEAR)

        # Initialize output image

        img = cv2.resize(temp, (width, height), interpolation=cv2.INTER_NEAREST)
        return img


class BlurItem(MyItem):
    def __init__(self, parent=None):
        super(BlurItem, self).__init__('模糊', parent=parent)
        self._size = 5

    def __call__(self, img):
        img = cv2.blur(img, (self._size, self._size))
        return img


class CandyStyleTransformItem(MyItem):
    def __init__(self, parent=None):
        super(CandyStyleTransformItem, self).__init__('candy', parent=parent)

    def __call__(self, img):
        net = cv2.dnn.readNetFromTorch("./style/candy.t7")
        net.setPreferableBackend(cv2.dnn.DNN_BACKEND_OPENCV)
        # img = cv2.imread("D:\\t\\1.jpg")
        # res = cv2.resize(img, (500, 300))
        row, column, _ = img.shape
        blob = cv2.dnn.blobFromImage(img, 1.0, (column, row), (103.939, 116.779, 123.680), swapRB=False, crop=False)
        net.setInput(blob)
        out = net.forward()
        out = out.reshape(3, out.shape[2], out.shape[3])
        out[0] += 103.939
        out[1] += 116.779
        out[2] += 123.680
        # output = out/255
        out = out.transpose(1, 2, 0)
        # output = output.transpose(1, 2, 0)
        # cv2.imshow("out", output)
        cv2.imwrite("tmp.jpg", out)
        out2 = cv2.imread("tmp.jpg")
        # out_res = cv2.resize(out, (500, 300))
        return out2


class CompositionStyleTransformItem(MyItem):
    def __init__(self, parent=None):
        super(CompositionStyleTransformItem, self).__init__('composition', parent=parent)

    def __call__(self, img):
        net = cv2.dnn.readNetFromTorch("./style/composition_vii.t7")
        net.setPreferableBackend(cv2.dnn.DNN_BACKEND_OPENCV)
        # img = cv2.imread("D:\\t\\1.jpg")
        # res = cv2.resize(img, (500, 300))
        row, column, _ = img.shape
        blob = cv2.dnn.blobFromImage(img, 1.0, (column, row), (103.939, 116.779, 123.680), swapRB=False, crop=False)
        net.setInput(blob)
        out = net.forward()
        out = out.reshape(3, out.shape[2], out.shape[3])
        out[0] += 103.939
        out[1] += 116.779
        out[2] += 123.680
        # output = out/255
        out = out.transpose(1, 2, 0)
        # output = output.transpose(1, 2, 0)
        # cv2.imshow("out", output)
        cv2.imwrite("tmp.jpg", out)
        out2 = cv2.imread("tmp.jpg")
        # out_res = cv2.resize(out, (500, 300))
        return out2


class FeathersStyleTransformItem(MyItem):
    def __init__(self, parent=None):
        super(FeathersStyleTransformItem, self).__init__('feathers', parent=parent)

    def __call__(self, img):
        net = cv2.dnn.readNetFromTorch("./style/feathers.t7")
        net.setPreferableBackend(cv2.dnn.DNN_BACKEND_OPENCV)
        # img = cv2.imread("D:\\t\\1.jpg")
        # res = cv2.resize(img, (500, 300))
        row, column, _ = img.shape
        blob = cv2.dnn.blobFromImage(img, 1.0, (column, row), (103.939, 116.779, 123.680), swapRB=False, crop=False)
        net.setInput(blob)
        out = net.forward()
        out = out.reshape(3, out.shape[2], out.shape[3])
        out[0] += 103.939
        out[1] += 116.779
        out[2] += 123.680
        # output = out/255
        out = out.transpose(1, 2, 0)
        # output = output.transpose(1, 2, 0)
        # cv2.imshow("out", output)
        cv2.imwrite("tmp.jpg", out)
        out2 = cv2.imread("tmp.jpg")
        # out_res = cv2.resize(out, (500, 300))
        return out2


class MuseStyleTransformItem(MyItem):
    def __init__(self, parent=None):
        super(MuseStyleTransformItem, self).__init__('la_muse', parent=parent)

    def __call__(self, img):
        net = cv2.dnn.readNetFromTorch("./style/la_muse.t7")
        net.setPreferableBackend(cv2.dnn.DNN_BACKEND_OPENCV)
        # img = cv2.imread("D:\\t\\1.jpg")
        # res = cv2.resize(img, (500, 300))
        row, column, _ = img.shape
        blob = cv2.dnn.blobFromImage(img, 1.0, (column, row), (103.939, 116.779, 123.680), swapRB=False, crop=False)
        net.setInput(blob)
        out = net.forward()
        out = out.reshape(3, out.shape[2], out.shape[3])
        out[0] += 103.939
        out[1] += 116.779
        out[2] += 123.680
        # output = out/255
        out = out.transpose(1, 2, 0)
        # output = output.transpose(1, 2, 0)
        # cv2.imshow("out", output)
        cv2.imwrite("tmp.jpg", out)
        out2 = cv2.imread("tmp.jpg")
        # out_res = cv2.resize(out, (500, 300))
        return out2


class MosaicStyleTransformItem(MyItem):
    def __init__(self, parent=None):
        super(MosaicStyleTransformItem, self).__init__('mosaic', parent=parent)

    def __call__(self, img):
        net = cv2.dnn.readNetFromTorch("./style/mosaic.t7")
        net.setPreferableBackend(cv2.dnn.DNN_BACKEND_OPENCV)
        # img = cv2.imread("D:\\t\\1.jpg")
        # res = cv2.resize(img, (500, 300))
        row, column, _ = img.shape
        blob = cv2.dnn.blobFromImage(img, 1.0, (column, row), (103.939, 116.779, 123.680), swapRB=False, crop=False)
        net.setInput(blob)
        out = net.forward()
        out = out.reshape(3, out.shape[2], out.shape[3])
        out[0] += 103.939
        out[1] += 116.779
        out[2] += 123.680
        # output = out/255
        out = out.transpose(1, 2, 0)
        # output = output.transpose(1, 2, 0)
        # cv2.imshow("out", output)
        cv2.imwrite("tmp.jpg", out)
        out2 = cv2.imread("tmp.jpg")
        # out_res = cv2.resize(out, (500, 300))
        return out2


class StarryNightStyleTransformItem(MyItem):
    def __init__(self, parent=None):
        super(StarryNightStyleTransformItem, self).__init__('starry_night', parent=parent)

    def __call__(self, img):
        net = cv2.dnn.readNetFromTorch("./style/starry_night.t7")
        net.setPreferableBackend(cv2.dnn.DNN_BACKEND_OPENCV)
        # img = cv2.imread("D:\\t\\1.jpg")
        # res = cv2.resize(img, (500, 300))
        row, column, _ = img.shape
        blob = cv2.dnn.blobFromImage(img, 1.0, (column, row), (103.939, 116.779, 123.680), swapRB=False, crop=False)
        net.setInput(blob)
        out = net.forward()
        out = out.reshape(3, out.shape[2], out.shape[3])
        out[0] += 103.939
        out[1] += 116.779
        out[2] += 123.680
        # output = out/255
        out = out.transpose(1, 2, 0)
        # output = output.transpose(1, 2, 0)
        # cv2.imshow("out", output)
        cv2.imwrite("tmp.jpg", out)
        out2 = cv2.imread("tmp.jpg")
        # out_res = cv2.resize(out, (500, 300))
        return out2


class ScreamStyleTransformItem(MyItem):
    def __init__(self, parent=None):
        super(ScreamStyleTransformItem, self).__init__('the_scream', parent=parent)

    def __call__(self, img):
        net = cv2.dnn.readNetFromTorch("./style/the_scream.t7")
        net.setPreferableBackend(cv2.dnn.DNN_BACKEND_OPENCV)
        # img = cv2.imread("D:\\t\\1.jpg")
        # res = cv2.resize(img, (500, 300))
        row, column, _ = img.shape
        blob = cv2.dnn.blobFromImage(img, 1.0, (column, row), (103.939, 116.779, 123.680), swapRB=False, crop=False)
        net.setInput(blob)
        out = net.forward()
        out = out.reshape(3, out.shape[2], out.shape[3])
        out[0] += 103.939
        out[1] += 116.779
        out[2] += 123.680
        # output = out/255
        out = out.transpose(1, 2, 0)
        # output = output.transpose(1, 2, 0)
        # cv2.imshow("out", output)
        cv2.imwrite("tmp.jpg", out)
        out2 = cv2.imread("tmp.jpg")
        # out_res = cv2.resize(out, (500, 300))
        return out2


class WaveStyleTransformItem(MyItem):
    def __init__(self, parent=None):
        super(WaveStyleTransformItem, self).__init__('the_wave', parent=parent)

    def __call__(self, img):
        net = cv2.dnn.readNetFromTorch("./style/the_wave.t7")
        net.setPreferableBackend(cv2.dnn.DNN_BACKEND_OPENCV)
        # img = cv2.imread("D:\\t\\1.jpg")
        # res = cv2.resize(img, (500, 300))
        row, column, _ = img.shape
        blob = cv2.dnn.blobFromImage(img, 1.0, (column, row), (103.939, 116.779, 123.680), swapRB=False, crop=False)
        net.setInput(blob)
        out = net.forward()
        out = out.reshape(3, out.shape[2], out.shape[3])
        out[0] += 103.939
        out[1] += 116.779
        out[2] += 123.680
        # output = out/255
        out = out.transpose(1, 2, 0)
        # output = output.transpose(1, 2, 0)
        # cv2.imshow("out", output)
        cv2.imwrite("tmp.jpg", out)
        out2 = cv2.imread("tmp.jpg")
        # out_res = cv2.resize(out, (500, 300))
        return out2


class UdnieStyleTransformItem(MyItem):
    def __init__(self, parent=None):
        super(UdnieStyleTransformItem, self).__init__('udnie', parent=parent)

    def __call__(self, img):
        net = cv2.dnn.readNetFromTorch("./style/udnie.t7")
        net.setPreferableBackend(cv2.dnn.DNN_BACKEND_OPENCV)
        # img = cv2.imread("D:\\t\\1.jpg")
        # res = cv2.resize(img, (500, 300))
        row, column, _ = img.shape
        blob = cv2.dnn.blobFromImage(img, 1.0, (column, row), (103.939, 116.779, 123.680), swapRB=False, crop=False)
        net.setInput(blob)
        out = net.forward()
        out = out.reshape(3, out.shape[2], out.shape[3])
        out[0] += 103.939
        out[1] += 116.779
        out[2] += 123.680
        # output = out/255
        out = out.transpose(1, 2, 0)
        # output = output.transpose(1, 2, 0)
        # cv2.imshow("out", output)
        cv2.imwrite("tmp.jpg", out)
        out2 = cv2.imread("tmp.jpg")
        # out_res = cv2.resize(out, (500, 300))
        return out2


class ClarityItem(MyItem):
    def __init__(self, parent=None):
        super(ClarityItem, self).__init__('锐化', parent=parent)

    def __call__(self, img):
        kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]], np.float32)
        dst = cv2.filter2D(img, -1, kernel=kernel)
        return dst


class NoiseItem(MyItem):
    def __init__(self, parent=None):
        super(NoiseItem, self).__init__('噪点', parent=parent)

    def __call__(self, img):
        num = int(0.02 * img.shape[0] * img.shape[1])  # 椒盐噪声点数量
        random.randint(0, img.shape[0])
        img2 = img.copy()
        for i in range(num):
            X = random.randint(0, img2.shape[0] - 1)  # 从0到图像长度之间的一个随机整数,因为是闭区间所以-1
            Y = random.randint(0, img2.shape[1] - 1)
            if random.randint(0, 1) == 0:  # 黑白色概率55开
                img2[X, Y] = (255, 255, 255)  # 白色
            else:
                img2[X, Y] = (0, 0, 0)  # 黑色
        return img2


class ImageCutItem(MyItem):
    def __init__(self, parent=None):
        super(ImageCutItem, self).__init__('裁剪', parent=parent)
        self._x1 = 0
        self._x2 = 300
        self._y1 = 200
        self._y2 = 600

    def __call__(self, img):
        dst = img[self._y1:self._y2, self._x1:self._x2]
        return dst