from PIL import Image
from PIL import ImageTk
from PIL import ImageFilter
from PIL import ImageEnhance

import tkinter as tk  # Tkinter: python内置GUI
from tkinter.filedialog import askopenfilename
import tkinter.ttk
import tkinter.messagebox
from tkinter import simpledialog

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torchvision.transforms as transforms
import torchvision.models as models

import numpy as np
import cv2 as cv
import matplotlib.pyplot as plt
import collections

#import os
#os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"

class picture(object):
    """description of class"""
    # 打开图像调用
    def open_pic(self, address):
        self.pic_get = Image.open(address).convert('RGBA')
        wid, hei = self.pic_get.size
        if wid > 600 or hei > 400:
            if tk.messagebox.askokcancel('提示', '图片可能过大,是否压缩?'):
                needShow_pic = self.openResize()
                return needShow_pic
            return self.pic_get
        else:
            return self.pic_get

    # 打开图像时的图像压缩展示
    def openResize(self):
        w, h = self.pic_get.size
        w_hope = 500
        h_hope = 300
        f1 = 1.0 * w_hope / w
        f2 = 1.0 * h_hope / h
        factor = min([f1, f2])
        width = int(w * factor)
        height = int(h * factor)
        pic_show = self.pic_get.resize((width, height))
        return pic_show
 
# 截图处理
    def Cutpic(self, pic_preCut, p1, p2, p3, p4):
        cropped_pic = pic_preCut.crop((p1, p2, p3, p4))#截图
        return cropped_pic

# 尺寸大小变化
    def changeResize(self, pic_reshow, newWidth, newHeight):
        reesizeNew_pic = pic_reshow.resize((newWidth, newHeight))#修改尺寸
        # print('3')
        return reesizeNew_pic


# 镜像左右
    def MirrorPic_leftOrright(self, pic_mir_lr):
        Mirror_lrFinish = pic_mir_lr.transpose(Image.Transpose.FLIP_LEFT_RIGHT)# 镜像左右
        return Mirror_lrFinish

# 镜像上下
    def MirrorPic_topOrbuttom(self, pic_mir_tp):
        Mirror_tbFinish = pic_mir_tp.transpose(Image.Transpose.FLIP_LEFT_RIGHT)# 镜像上下
        return Mirror_tbFinish
# 旋转
    def rotatePic(self, pic_prerotate, rodegreee):
        rotateNew_pic = pic_prerotate.rotate(rodegreee, expand=True)
        return rotateNew_pic
# 亮度
    def brightPic(self, pic_prebright, n):
        pic_brighted = ImageEnhance.Brightness(pic_prebright).enhance(n)# 亮度
        return pic_brighted

# 色彩度
    def colornPic(self, pic_preColor, n):
        pic_colored = ImageEnhance.Color(pic_preColor).enhance(n)# 色彩度
        return pic_colored

# 对比度
    def constractPic(self, pic_preCon, n):
        enh_con = ImageEnhance.Contrast(pic_preCon)
        contrast = n
        pic_contrasted = enh_con.enhance(contrast)# 对比度
        return pic_contrasted

# 锐度调整
    def sharpPic(self, pic_preSharp, n):
        pic_sharped = ImageEnhance.Sharpness(pic_preSharp).enhance(n)
        return pic_sharped


class modules(object):

    def forward(self, img):
        # normalize img
        return (img - self.mean) / self.std


    """description of class"""
    # 加了滤镜的拓展功能，用的ImageFilter库
    def blurPic(Imf):
        Im2 = Imf.filter(ImageFilter.BLUR)  # 图像模糊
        return Im2

    def edge(Imf):
        Im4 = Imf.filter(ImageFilter.EDGE_ENHANCE)  # 边界增强
        return Im4

    def gaussianBlur(Imf):
        Im6 = Imf.filter(ImageFilter.GaussianBlur)  # 高斯模糊
        return Im6

    def emboss(Imf):
        Im8 = Imf.filter(ImageFilter.EMBOSS)  # 浮雕滤镜，
        return Im8

    # 线性灰度转换
    def linearization(Imf, a, c):
        Im12=np.array(Imf)
        r,g,b = Im12[:,:,0], Im12[:,:,1], Im12[:,:,2]
        Im12 = 0.2989*r + 0.5870*g + 0.1140*b
        Im12=float(a)*Im12+float(c) # 对矩阵类型计算,a是对比度，c是亮度，由k和b传入
        # 进行数据截断，大于255的值要截断为255
        Im12[Im12>255]=255
        # 数据类型转化
        Im12=np.round(Im12)
        Im12=Im12.astype(np.uint8)
        return Image.fromarray(Im12)
    # 非线性log灰度转换
    def tologpic(Imf, c):
        Im14=np.array(Imf)
        r,g,b = Im14[:,:,0], Im14[:,:,1], Im14[:,:,2]
        Im14 = 0.2989*r + 0.5870*g + 0.1140*b
        Im14 = c * np.log(1.0 + Im14) # 对数运算
        Im14[Im14>255]=255 #
        Im14 = np.uint8(Im14 + 0.5)
        return Image.fromarray(Im14)
    # n值灰度转换
    def tonpic(Imf, n):
        Im16=np.array(Imf)
        r,g,b = Im16[:,:,0], Im16[:,:,1], Im16[:,:,2]
        Im16 = 0.2989*r + 0.5870*g + 0.1140*b
        Im16=float(n)*Im16
        
        Im16[Im16>255]=255
        # 数据类型转化
        Im16=np.round(Im16)
        Im16=Im16.astype(np.uint8)
        return Image.fromarray(Im16)

    def calc_hist(gray):
        # 计算彩色图单通道的直方图
        hist_new = []
        num = []
        hist_result = []
        hist_key = []
        gray1 = list(gray.ravel()) # 将读取出来的数组转化为一维列表方便循环遍历
        obj = dict(collections.Counter(gray1)) # 计算每个灰度级出现的次数
        obj = sorted(obj.items(),key=lambda item:item[0])
        # 初始化hist数组
        for each in obj:
            hist1 = []
            key = list(each)[0]
            cnt = list(each)[1]
            hist_key.append(key)
            hist1.append(cnt)
            hist_new.append(hist1)
        # 检查从0-255每个通道是否都有个数，没有的话添加并将值设为0
        for i in range (0, 256):
            if i in hist_key:
                num = hist_key.index(i)
                hist_result.append(hist_new[num])
            else:
                hist_result.append([0])
        hist_result = np.array(hist_result)
        return hist_result

    # 计算直方图
    def showhist(image):
        image= np.array(image)
        r,g,b = image[:,:,0], image[:,:,1], image[:,:,2]

        hist_new_b = modules.calc_hist(b)
        hist_new_g = modules.calc_hist(g)
        hist_new_r = modules.calc_hist(r)

        # 绘制直方图
        plt.plot(hist_new_b, color='b')
        plt.plot(hist_new_g, color='g')
        plt.plot(hist_new_r, color='r')
        plt.show()

    # 图像相加函数
    def IMG_PLUS(img1, img2):
        # 先修改img1尺寸和img2相同
        img1 = cv.resize(img1, (img2.shape[1], img2.shape[0]))
        # 矩阵相加
        newimg = img1*0.5 + img2*0.5
        newimg = newimg.astype(np.uint8)
        return newimg

    # 图像相加
    def Add(img1, img2):
        first = np.array(img1)
        second = np.array(img2)
        newimg = modules.IMG_PLUS(first, second)
        #return ImageTk.PhotoImage(Image.fromarray(newimg))
        return Image.fromarray(newimg)

    # 均值滤波处理函数
    def mean_filter(img, b=3):
        padnum = (b-1)//2# 填充数量
        pad = ((padnum, padnum), (padnum, padnum), (0,0))# 填充格式
        Filter = np.ones((b, b, img.shape[2]), img.dtype)# 方阵滤波器
        padnumImg= np.pad(img, pad, 'constant', constant_values=(0, 0))
        # 用滤波器对图像中像素依次计算取均值
        for i in range(padnum, padnumImg.shape[0] - padnum):
            for j in range(padnum, padnumImg.shape[1] - padnum):
                padnumImg[i][j] = (Filter * padnumImg[i-padnum:i+padnum+1, j-padnum:j+padnum+1]).sum(axis = 0).sum(axis = 0)//(b ** 2)
        newimg = padnumImg[padnum:padnumImg.shape[0] - padnum, padnum:padnumImg.shape[1] - padnum]  # 剪切使尺寸一样
        return newimg

    # 中值滤波处理函数
    def median_filter(img, b=3):
        padnum = (b-1)//2# 填充数量
        pad = ((padnum, padnum), (padnum, padnum), (0,0))# 填充格式
        padImg= np.pad(img, pad, 'constant', constant_values=(0, 0))# 方阵滤波器
        # 按通道计算中值函数
        def DimensionAdd(img):
            blank = np.zeros((img.shape[2]))
            for i in range(img.shape[2]):
                blank[i] = np.median(img[:,:,i])
            return blank
        # 用滤波器对图像中像素依次计算中值
        for i in range(padnum, padImg.shape[0] - padnum):
            for j in range(padnum, padImg.shape[1] - padnum):
                padImg[i][j] = DimensionAdd(padImg[i-padnum:i+padnum+1, j-padnum:j+padnum+1])
        newimg = padImg[padnum:padImg.shape[0] - padnum, padnum:padImg.shape[1] - padnum]  # 把操作完多余的0去除，保证尺寸一样大
        return newimg

    # 均值滤波
    def filter1(img):
        l = simpledialog.askinteger(title='滤波核size', prompt='边长L', initialvalue=3, minvalue=0, maxvalue=99)
        img = modules.mean_filter(np.array(img), l)
        return ImageTk.PhotoImage(Image.fromarray(img))

    # 中值滤波
    def filter2(img):
        l = simpledialog.askinteger(title='滤波核size', prompt='边长L', initialvalue=3, minvalue=0, maxvalue=99)
        img = modules.median_filter(np.array(img), l)
        return ImageTk.PhotoImage(Image.fromarray(img))

    # sobel锐化
    def sharpen(img):
        
        img = np.array(img)
        r,g,b = img[:,:,0], img[:,:,1], img[:,:,2]
        img = 0.2989*r + 0.5870*g + 0.1140*b
        # sobel算子
        G_x = np.array([[-1, 0, 1],[-2, 0, 2],[-1, 0, 1]])
        G_y = np.array([[-1, -2, -1],[0, 0, 0],[1, 2, 1]])
        rows = np.size(img, 0)
        columns = np.size(img, 1)
        mag = np.zeros(img.shape)
        # 分别检测水平和垂直，在计算每个pixel的时候，将水平和垂直的值作一次平方和的处理
        for i in range(0, rows - 2):
            for j in range(0, columns - 2):
                v = sum(sum(G_x * img[i:i+3, j:j+3]))  # vertical
                h = sum(sum(G_y * img[i:i+3, j:j+3]))  # horizon
                mag[i+1, j+1] = np.sqrt((v ** 2) + (h ** 2))
        # 设置阈值
        threshold=120
        mag[mag<threshold] = 0

        mag = mag.astype(np.uint8)
        return Image.fromarray(mag)


    def style_transfer(content_img, style_img, steps):
        result = solver.run(content_img, style_img, steps)
        return result

        
# ---风格转换相关---
# 内容损失
class ContentLoss(nn.Module):
    def __init__(self, target,):
        super(ContentLoss, self).__init__()
        # 将目标内容从用于动态计算梯度的树中“分离”出来
        self.target = target.detach()

    def forward(self, input):
        self.loss = F.mse_loss(input, self.target)
        return input


def gram_matrix(input):
    a, b, c, d = input.size()
    # a:=batch size(=1)
    # b:=number of feature maps
    # (c,d):=dimensions of a f. map (N=c*d)

    features = input.view(a * b, c * d)

    G = torch.mm(features, features.t())  # 计算格拉姆矩阵

    # 矩阵标准化
    return G.div(a * b * c * d)

# 风格损失
class StyleLoss(nn.Module):

    def __init__(self, target_feature):
        super(StyleLoss, self).__init__()
        self.target = gram_matrix(target_feature).detach()

    def forward(self, input):
        G = gram_matrix(input)
        self.loss = F.mse_loss(G, self.target)
        return input


# 创建一个模块来标准化输入的图像，使其能被放在nn.Sequential中
class Normalization(nn.Module):
    def __init__(self, mean, std):
        super(Normalization, self).__init__()
        # .view the mean and std to make them [C x 1 x 1] so that they can
        # directly work with image Tensor of shape [B x C x H x W].
        # B is batch size. C is number of channels. H is height and W is width.
        self.mean = mean.clone().detach().view(-1, 1, 1)
        self.std = std.clone().detach().view(-1, 1, 1)

    def forward(self, img):
        # normalize img
        return (img - self.mean) / self.std

class solver(object):
    content_layers_default = ['conv_4']
    style_layers_default = ['conv_1', 'conv_2', 'conv_3', 'conv_4', 'conv_5']
    unloader = transforms.ToPILImage()  # 转换到PIL格式
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        # 期望输出图像的大小
    imsize = 512
    loader = transforms.Compose([
        # 缩放图片大小
        transforms.Resize(imsize),
        # 转换成pytorch tensor形式
        transforms.ToTensor()])

    def load_image(image_name):
        image = solver.loader(image_name).unsqueeze(0)
        return image.to(solver.device, torch.float)

    # 打印图像
    def show_image(tensor, title=None):
        image = tensor.cpu().clone()  # 复制参数tensor
        image = image.squeeze(0) # 削减无用维度
        image = solver.unloader(image)
        plt.imshow(image)
        if title is not None:
            plt.title(title)
        plt.pause(1)
        return image

    def get_style_model_and_losses(cnn, normalization_mean, normalization_std,
                                   style_img, content_img,
                                   content_layers=content_layers_default,
                                   style_layers=style_layers_default):
        # 标准化模块
        normalization = Normalization(normalization_mean, normalization_std).to(solver.device)

        content_losses = []
        style_losses = []

        # 使用的是nn.Sequential, 则建立一个新的nn.Sequential
        # 放入模块，会按顺序激活
        model = nn.Sequential(normalization)

        i = 0  # 每次看到一个conv层就增加
        for layer in cnn.children():
            if isinstance(layer, nn.Conv2d):
                i += 1
                name = 'conv_{}'.format(i)
            elif isinstance(layer, nn.ReLU):
                name = 'relu_{}'.format(i)
                layer = nn.ReLU(inplace=False)
            elif isinstance(layer, nn.MaxPool2d):
                name = 'pool_{}'.format(i)
            elif isinstance(layer, nn.BatchNorm2d):
                name = 'bn_{}'.format(i)
            else:
                raise RuntimeError('Unrecognized layer: {}'.format(layer.__class__.__name__))

            model.add_module(name, layer)

            if name in content_layers:
                # 加入内容损失:
                target = model(content_img).detach()
                content_loss = ContentLoss(target)
                model.add_module("content_loss_{}".format(i), content_loss)
                content_losses.append(content_loss)

            if name in style_layers:
                # 加入风格损失:
                target_feature = model(style_img).detach()
                style_loss = StyleLoss(target_feature)
                model.add_module("style_loss_{}".format(i), style_loss)
                style_losses.append(style_loss)

        for i in range(len(model) - 1, -1, -1):
            if isinstance(model[i], ContentLoss) or isinstance(model[i], StyleLoss):
                break
            
        model = model[:(i + 1)]
        return model, style_losses, content_losses

    def get_input_optimizer(input_img):
        optimizer = optim.LBFGS([input_img])
        return optimizer

    def run_style_transfer(cnn, normalization_mean, normalization_std,
                           content_img, style_img, input_img, num_steps=300,
                           style_weight=1000000, content_weight=1):
        """Run the style transfer."""
        print('Building the style transfer model..')
        model, style_losses, content_losses = solver.get_style_model_and_losses(cnn,
            normalization_mean, normalization_std, style_img, content_img)

        # 优化输入而不是模型参数，因此更新所有requires_grad字段
        input_img.requires_grad_(True)
        model.requires_grad_(False)

        optimizer = solver.get_input_optimizer(input_img)

        print('Optimizing..')
        run = [0]
        while run[0] <= num_steps:

            def closure():
                # 修正更新后的输入图像的值
                with torch.no_grad():
                    input_img.clamp_(0, 1)

                optimizer.zero_grad()
                model(input_img)
                style_score = 0
                content_score = 0

                for sl in style_losses:
                    style_score += sl.loss
                for cl in content_losses:
                    content_score += cl.loss

                style_score *= style_weight
                content_score *= content_weight

                loss = style_score + content_score
                loss.backward()

                run[0] += 1
                if run[0] % 50 == 0:
                    print("run {}:".format(run))
                    print('Style Loss: {:4f} Content Loss: {:4f}'.format(
                        style_score.item(), content_score.item()))
                    print()

                return style_score + content_score

            optimizer.step(closure)

        with torch.no_grad():
            input_img.clamp_(0, 1)

        return input_img

    def run(content_img, style_img, steps):

        content_img = solver.load_image(content_img.convert('RGB'))
        style_img = solver.load_image(style_img.convert('RGB'))

        # 风格图像和内容图像大小要保持一致
        assert style_img.size() == content_img.size(), "Error"

        #plt.ion()
        #plt.figure()
        #solver.show_image(style_img, title='Style Image')

        #plt.figure()
        #solver.show_image(content_img, title='Content Image')

        cnn = models.vgg19(weights='VGG19_Weights.DEFAULT').features.to(solver.device).eval()
        cnn_normalization_mean = torch.tensor([0.485, 0.456, 0.406]).to(solver.device)
        cnn_normalization_std = torch.tensor([0.229, 0.224, 0.225]).to(solver.device)

        input_img = content_img.clone()
        # input_img = torch.randn(content_img.data.size(), device=device)

        output = solver.run_style_transfer(cnn, cnn_normalization_mean, cnn_normalization_std,
                            content_img, style_img, input_img, steps)

        plt.figure()
        result = solver.show_image(output, title='Output Image')


        
        # plt.ioff()
        # plt.show()


        return result
        

class Win(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title('图像处理期末demo')
        self.geometry('1080x720')
        self.picture = picture()  # self.picture将作为picture类的实例化对象
        self.img = None  # self.img将作为窗口类中一直变动的PIL对象图片

        self.setupUI()

    def setupUI(self):
        # 右边菜单栏
        right_f = tk.Frame(self, height=720, width=360,bg="#FFFFFF")
        right_f.pack(side=tk.RIGHT)

        # 各种功能按钮名称及位置
        btn1 = tk.Button(right_f, text='打开图像',fg='#FFFFFF', bg="#7C3338",command=self.open_picture)
        btn1.place(y=25, x=30, width=300, height=40)
        btn2 = tk.Button(right_f, text='基本调整', bg="#FFE498", command=self.basic_proc)
        btn2.place(y=85, x=30, width=144, height=40)
        btn3 = tk.Button(right_f, text='调整大小', bg="#FFE498", command=self.picture_resize)
        btn3.place(y=85, x=186, width=144,height=40)
        btn4 = tk.Button(right_f, text='旋转操作', bg='#FFE498', command=self.picture_rotate)
        btn4.place(y=145, x=30, width=144, height=40)
        btn5 = tk.Button(right_f, text='镜像操作', bg='#FFE498',command=self.picture_mirror)
        btn5.place(y=145, x=186, width=144, height=40)
        btn6 = tk.Button(right_f, text='灰度变换', bg='#FFE498',command=self.picture_gray)
        btn6.place(y=205, x=30, width=144, height=40)
        btn7 = tk.Button(right_f, text='滤镜', bg='#FFE498',command=self.picture_filters)
        btn7.place(y=205, x=186, width=144, height=40)
        btn8 = tk.Button(right_f, text='显示直方图', bg='#FFE498',command=self.show_hist)
        btn8.place(y=265, x=30, width=144, height=40)
        btn9 = tk.Button(right_f, text='图像相加', bg='#FFE498',command=self.add_picture)
        btn9.place(y=265, x=186, width=144, height=40)
        btn10 = tk.Button(right_f, text='滤波', bg='#FFE498',command=self.filtering)
        btn10.place(y=325, x=30, width=144, height=40)
        btn11 = tk.Button(right_f, text='Sobel锐化', bg='#FFE498',command=self.sharpening)
        btn11.place(y=325, x=186, width=144, height=40)
        btn12 = tk.Button(right_f, text='风格转换', bg='#FFE498',command=self.style_transfer)
        btn12.place(y=385, x=30, width=144, height=40)

        # 底部恢复、保存、对比
        btn13 = tk.Button(right_f, text='保存图像',fg='#FFFFFF', command=self.save_pic,bg="#7C3338")
        btn13.place(y=590, x=230, width=90, height=30)
        btn14 = tk.Button(right_f, text='恢复图像',fg='#FFFFFF', command=self.replay,bg="#7C3338")
        btn14.place(y=590, x=30, width=90, height=30)
        btn15 = tk.Button(right_f, text='对比图像',fg='#FFFFFF', command=self.compare,bg="#7C3338")
        btn15.place(y=590, x=130, width=90, height=30)


        # 图像显示栏
        right_f = tk.Frame(self, height=720, width=720)
        right_f.pack(side=tk.RIGHT)
        self.image_l = tk.Label(right_f, relief='ridge')
        self.image_l.place(x=0, y=0, width=720, height=720)

    def filtering(self):
        filter_win = tk.Toplevel()
        filter_win.title('滤波选择')
        filter_win.geometry('150x150')
        b1 = tk.Button(filter_win, text='均值滤波', command=self.filter1)
        b1.place(y=30, x=35, width=75)
        b2 = tk.Button(filter_win, text='中值滤波', command=self.filter2)
        b2.place(y=60, x=35, width=75)
        b3 = tk.Button(filter_win, text='完成', command=filter_win.destroy)
        b3.place(y=110, x=80, width=40)

    def sharpening(self):
        sharpen_pic = self.img
        sharpen_pic = modules.sharpen(sharpen_pic)
        self.show_img(sharpen_pic)
    # 打开图片时使用，传值(图)给展示函数
    def open_picture(self):
        address = self.getAddress()
        self.open_picToimg = self.picture.open_pic(address)
        self.firstPic(self.open_picToimg)
        self.show_img(self.open_picToimg)

    # 打开图片时使用，传值(图)给展示函数
    def add_picture(self):
        address = self.getAddress()
        self.open_picToimg = self.picture.open_pic(address)
        self.add_pic(self.open_picToimg)
        
    def filter1(self):
        img_show = modules.filter1(self.img)
        self.image_l.config(image=img_show)
        self.image_l.image = img_show
        return self.img

    def filter2(self):
        img_show = modules.filter2(self.img)
        self.image_l.config(image=img_show)
        self.image_l.image = img_show
        return self.img

    # 打开图片时使用，获得地址
    def getAddress(self):
        path = tk.StringVar()
        file_entry = tk.Entry(self, state='readonly', text=path)
        path_ = askopenfilename()
        path.set(path_)

        return file_entry.get()

    # 展示函数
    def show_img(self, n_img):
        self.img = n_img  # self.img PIL对象方便传值给picture类以及本类中其他需要使用PIL图像的地方
        img_show = ImageTk.PhotoImage(self.img)
        self.image_l.config(image=img_show)
        self.image_l.image = img_show
        return self.img

    def add_pic(self, n_img):
        img_show = n_img
        img_show = modules.Add(img_show, self.img)
        self.show_img(img_show)
        
    
    # 保存函数
    def save_pic(self):
        fname = tkinter.filedialog.asksaveasfilename(title='保存文件', filetypes=[("PNG", ".png")])
        self.img.save(str(fname))  # PIL保存

    # 原图储存
    def firstPic(self, pic):
        self.Fpic = pic
        return self.Fpic
    
    # 打开图像时的图像压缩展示
    def openResize(self):
        w, h = self.pic_get.size
        w_hope = 500
        h_hope = 300
        f1 = 1.0 * w_hope / w
        f2 = 1.0 * h_hope / h
        factor = min([f1, f2])
        width = int(w * factor)
        height = int(h * factor)
        pic_show = self.pic_get.resize((width, height))
        return pic_show


    # 基本操作
    def basic_proc(self):
        Bas_win = tk.Toplevel()
        Bas_win.title('基本调整')
        Bas_win.geometry('250x250')

        l0 = tk.Label(Bas_win, text="%")
        l0.place(y=30, x=100)
        self.i0 = tk.Entry(Bas_win, width=13)#输入参数n
        self.i0.place(y=30, x=20)
        bt1 = tk.Button(Bas_win, text='亮度调整', command=self.brightnessPic)
        bt1.place(y=25, x=130, width=80)

        l1 = tk.Label(Bas_win, text="%")
        l1.place(y=65, x=100)
        self.i1 = tk.Entry(Bas_win, width=13)#输入参数n
        self.i1.place(y=70, x=20)
        bt2 = tk.Button(Bas_win, text='色彩度调整', command=self.colorPic)
        bt2.place(y=65, x=130, width=80)

        l2 = tk.Label(Bas_win, text="%")
        l2.place(y=105, x=100)
        self.i2 = tk.Entry(Bas_win, width=13)#输入参数n
        self.i2.place(y=110, x=20)
        bt3 = tk.Button(Bas_win, text='对比度调整', command=self.contrastPic)
        bt3.place(y=105, x=130, width=80)

        l3 = tk.Label(Bas_win, text="%")
        l3.place(y=145, x=100)
        self.i3 = tk.Entry(Bas_win, width=13)#输入参数n
        self.i3.place(y=150, x=20)
        bt4 = tk.Button(Bas_win, text='锐度调整', command=self.sharpnessPic)
        bt4.place(y=145, x=130, width=80)

        bt6 = tk.Button(Bas_win, text='完成', command=Bas_win.destroy)
        bt6.place(y=200, x=100)

    # 大小尺寸操作窗口
    def picture_resize(self):
        Size_win = tk.Toplevel()
        Size_win.title('尺寸操作')
        Size_win.geometry('300x180')
        l1 = tk.Label(Size_win, text="宽:")
        l1.place(y=30, x=80)
        self.text1 = tk.Entry(Size_win, width=10)
        self.text1.place(y=30, x=100)
        l1_1 = tk.Label(Size_win, text="px")
        l1_1.place(y=30, x=170)
        l2 = tk.Label(Size_win, text="高:")
        l2.place(y=60, x=80)
        self.text2 = tk.Entry(Size_win, width=10)
        self.text2.place(y=60, x=100)
        l2_1 = tk.Label(Size_win, text="px")
        l2_1.place(y=60, x=170)
        b1 = tk.Button(Size_win, text='确定', command=self.getSize_change)
        b1.place(y=100, x=100, width=40)
        b2 = tk.Button(Size_win, text='完成', command=Size_win.destroy)
        b2.place(y=145, x=100, width=40)


    # 获得输入尺寸
    def getSize_change(self):
        sizeNum_w = int(self.text1.get())
        sizeNum_h = int(self.text2.get())
        # print('1')
        self.showSize_change(sizeNum_w, sizeNum_h)
        # print(sizeNum_w, sizeNum_h)

    # 尺寸修改并展示图片
    def showSize_change(self, renewSize_w, renewSize_h):
        # print('2')
        
        needResize_pic = self.img
        show_resizePic = self.picture.changeResize(needResize_pic, renewSize_w, renewSize_h)
        self.show_img(show_resizePic)

    # 灰度转换功能窗口
    def picture_gray(self):
        Word_win = tk.Toplevel()
        Word_win.title('灰度变化')
        Word_win.geometry('300x400')
        l1 = tk.Label(Word_win, text='请选择灰度转换方法:')
        l1.place(y=10, x=20, width=130)
        l0 = tk.Label(Word_win, text="n(n值默认1.5):")
        l0.place(y=40, x=20)
        self.i0 = tk.Entry(Word_win, width=13)#输入参数n
        self.i0.place(y=40, x=110)
        bt1 = tk.Button(Word_win, text='n值化', command=self.getn)
        bt1.place(y=70, x=20, width=80)

        l2 = tk.Label(Word_win, text="k(对比度默认1.5):")
        l2.place(y=110, x=20)
        self.i1 = tk.Entry(Word_win, width=13)#输入线性化参数k
        self.i1.place(y=110, x=110)
        l3 = tk.Label(Word_win, text="b(亮度默认1.5):")
        l3.place(y=130, x=20)
        self.i2 = tk.Entry(Word_win, width=13)#输入线性化参数b
        self.i2.place(y=130, x=110)
        bt2 = tk.Button(Word_win, text='线性化', command=self.getkb)
        bt2.place(y=160, x=20, width=80)

        
        l3 = tk.Label(Word_win, text="c(尺度比较常数默认30.0):")
        l3.place(y=200, x=20)
        self.i3 = tk.Entry(Word_win, width=13)#输入参数c
        self.i3.place(y=200, x=150)
        bt3 = tk.Button(Word_win, text='非线性化(对数转换)', command=self.getc)
        bt3.place(y=230, x=20, width=120)
        b7 = tk.Button(Word_win, text='完成', command=Word_win.destroy)
        b7.place(y=300, x=210)
    # 获得输入的n值转换值
    def getn(self):
        npic = self.img
        #n = float(self.i0.get())
        # 图像线性化获取展示
        npic= modules.tonpic(npic,
                            1.5 if self.i0.get()=="" else float(self.i0.get()))
        self.show_img(npic)
    # 获得输入的线性转换值
    def getkb(self):
        linearpic = self.img
        #k = float(self.i1.get())
        #b = float(self.i2.get())
        # 图像线性化获取展示
        linearpic= modules.linearization(linearpic,
                                         1.5 if self.i1.get()=="" else float(self.i1.get()),
                                         1.5 if self.i2.get()=="" else float(self.i2.get()))
        self.show_img(linearpic)
    # 获得输入的对数转换值
    def getc(self):
        logpic = self.img
        #c = float(self.i3.get())
        # 图像对数化获取展示
        logpic= modules.tologpic(logpic,
                                 30.0 if self.i3.get()=="" else float(self.i3.get()))
        self.show_img(logpic)

    # 图像旋转操作窗口
    def picture_rotate(self):
        Rot_win = tk.Toplevel()
        Rot_win.title('旋转操作')
        Rot_win.geometry('225x220')
        l1 = tk.Label(Rot_win, text="逆时针角度:")
        l1.place(y=20, x=10)
        self.inpt = tk.Entry(Rot_win, width=15)
        self.inpt.place(y=20, x=70)
        b0 = tk.Button(Rot_win, text='确定', command=lambda: self.getDegree('1'))
        b0.place(y=15, x=170, width=40)
        b1 = tk.Button(Rot_win, text='+90', command=lambda: self.getDegree('2'))
        b1.place(y=85, x=70, width=95)
        b2 = tk.Button(Rot_win, text='-90', command=lambda: self.getDegree('3'))
        b2.place(y=115, x=70, width=95)
        b3 = tk.Button(Rot_win, text='180', command=lambda: self.getDegree('4'))
        b3.place(y=145, x=70, width=95)
        b4 = tk.Button(Rot_win, text='完成', command=Rot_win.destroy)
        b4.place(y=180, x=100, width=40)

    # 旋转角度获取
    def getDegree(self, n):

        needRotate_pic = self.img
        # print('99')
        # print(n)
        if n == '1':
            inputDegree = float(self.inpt.get())
            showRotate_pic = self.picture.rotatePic(needRotate_pic, inputDegree)
        elif n == '2':
            # print('34')
            showRotate_pic = self.picture.rotatePic(needRotate_pic, +90)
        elif n == '3':
            showRotate_pic = self.picture.rotatePic(needRotate_pic, -90)
        elif n == '4':
            showRotate_pic = self.picture.rotatePic(needRotate_pic, 180)
        else:
            return 0
        self.show_img(showRotate_pic)

    # 滤镜选择窗口
    def picture_filters(self):
        Sty_win = tk.Toplevel()
        Sty_win.title('滤镜选择')
        Sty_win.geometry('230x180')
        bt1 = tk.Button(Sty_win, text='图像模糊', command=self.sty_1)
        bt1.place(y=25, x=25, width=80)
        bt2 = tk.Button(Sty_win, text='轮廓滤波', command=self.sty_2)
        bt2.place(y=25, x=115, width=80)
        bt3 = tk.Button(Sty_win, text='高斯模糊', command=self.sty_3)
        bt3.place(y=65, x=25, width=80)
        bt4 = tk.Button(Sty_win, text='浮雕滤镜', command=self.sty_4)
        bt4.place(y=65, x=115, width=80)
        bt6 = tk.Button(Sty_win, text='完成', command=Sty_win.destroy)
        bt6.place(y=140, x=160)

    # 图像模糊获取展示
    def sty_1(self):
        sty_1_pic = self.img
        relSty_1 = modules.blurPic(sty_1_pic)
        self.show_img(relSty_1)

    # 边界增强获取展示
    def sty_2(self):
        sty_2_pic = self.img
        reSty_2 = modules.edge(sty_2_pic)
        self.show_img(reSty_2)

    # 高斯模糊获取展示
    def sty_3(self):
        sty_3_pic = self.img
        reSty_3 = modules.gaussianBlur(sty_3_pic)
        self.show_img(reSty_3)

    # 浮雕滤镜获取展示
    def sty_4(self):
        sty_4_pic = self.img
        reSty_4 = modules.emboss(sty_4_pic)
        self.show_img(reSty_4)

    # 亮度调整
    def brightnessPic(self):
        
        needBright_pic = self.img
        b_num = float(self.i0.get())
        briNum = b_num / 100
        showBright_pic = self.picture.brightPic(needBright_pic, briNum)
        self.show_img(showBright_pic)

    # 色彩度调整
    def colorPic(self):
        
        needColor_pic = self.img
        co_num = float(self.i1.get())
        colNum = co_num / 100
        showColor_pic = self.picture.colornPic(needColor_pic, colNum)
        self.show_img(showColor_pic)

    # 对比度调整
    def contrastPic(self):
        
        needCon_pic = self.img
        c_num = float(self.i2.get())
        ConNum = c_num / 100
        showContrast_pic = self.picture.constractPic(needCon_pic, ConNum)
        self.show_img(showContrast_pic)

    # 锐度调整
    def sharpnessPic(self):
        
        needSharp_pic = self.img
        s_num = float(self.i3.get())
        ShNum = s_num / 100
        showSharp_pic = self.picture.constractPic(needSharp_pic, ShNum)
        self.show_img(showSharp_pic)


    def open_style_img_and_run(self):
        address = self.getAddress()
        self.style_img = self.picture.open_pic(address)
        content_img = self.img

        self.style_img = self.style_img.resize((content_img.width, content_img.height))

        # prompt
        Prompt_win = tk.Toplevel()
        Prompt_win.title('提示')
        Prompt_win.geometry('230x150')
        l1 = tk.Label(Prompt_win, text="output image生成中,保持终端打开...")
        l1.place(y=30, x=25)
        self.update()

        result = modules.style_transfer(content_img, self.style_img, int(300 if len(self.inpt.get())==0 else self.inpt.get()))
        self.show_img(result)

        Prompt_win.destroy()


    # 风格转换
    def style_transfer(self):
        Sty_win = tk.Toplevel()
        Sty_win.title('风格转换')
        Sty_win.geometry('300x200')

        bt1 = tk.Button(Sty_win, text='选择风格图像并运行(主窗口显示图像为内容图像)', command=self.open_style_img_and_run)
        bt1.place(y=60, x=25, width=250)
        l1 = tk.Label(Sty_win, text="步数(越大越慢,默认300)")
        l1.place(y=25, x=25)

        self.inpt = tk.Entry(Sty_win, width=10)
        self.inpt.place(y=25, x=150)
        
        bt2 = tk.Button(Sty_win, text='完成', command=Sty_win.destroy)
        bt2.place(y=150, x=130)


    # 镜像操作窗口
    def picture_mirror(self):
        Mir_win = tk.Toplevel()
        Mir_win.title('镜像操作')
        Mir_win.geometry('300x150')
        b1 = tk.Button(Mir_win, text='左右', command=self.MirrorImg_lr)
        b1.place(y=30, x=100, width=75)
        b2 = tk.Button(Mir_win, text='上下', command=self.MirrorImg_tb)
        b2.place(y=60, x=100, width=75)
        b3 = tk.Button(Mir_win, text='完成', command=Mir_win.destroy)
        b3.place(y=110, x=100, width=40)

    # 镜像左右调用展示
    def MirrorImg_lr(self):
        
        Mirror_img_lr = self.img
        MittotImg_lrFinish = self.picture.MirrorPic_leftOrright(Mirror_img_lr)
        self.show_img(MittotImg_lrFinish)

    # 镜像上下调用展示
    def MirrorImg_tb(self):
        
        Mirror_img_tb = self.img
        MittotImg_tbFinish = self.picture.MirrorPic_topOrbuttom(Mirror_img_tb)
        self.show_img(MittotImg_tbFinish)

    # 恢复图像
    def replay(self):
        self.show_img(self.Fpic)

    # 对比图像
    def compare(self):
        Image._show(self.Fpic)

    def show_hist(self):
        #gethist = modules.showhist(self.img)
        #self.show_img(gethist)
        modules.showhist(self.img)


if __name__ == '__main__':
    root = Win()
    # 窗体主循环
    root.mainloop()