种子特征检测及界面设计

女爷i 2022-11-15 11:22 6阅读 0赞

# 效果图 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hb19odWlfZmVp_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hb19odWlfZmVp_size_16_color_FFFFFF_t_70 1]

# 原图 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hb19odWlfZmVp_size_16_color_FFFFFF_t_70_pic_center]

# 主界面代码 #

main\_gui.py

# -*- coding: utf-8 -*-
    '''************************************************************************** #lab色彩模型是由照度（L）和有关色彩的a, b三个要素组成。L表示照度（Luminosity），相当于亮度， # a表示从红色至绿色的范围，b表示从蓝色至黄色的范围。L的值域由0到100，L=50时， # 就相当于50%的黑；a和b的值域都是由+120至-120，其中+120 a就是红色，渐渐过渡到-120 a的时候 # 就变成绿色；同样原理，+120 b是黄色，-120 b是蓝色。所有的颜色就以这三个值交互变化所组成。 ***************************************************************************'''
    from __future__ import division, print_function, absolute_import
    
    from PIL import Image
    import cv2 as cv
    from matplotlib import pyplot as plt
    
    import numpy as np
    import sys
    
    from PyQt5 import QtCore, QtGui, QtWidgets
    from PyQt5.QtWidgets import *
    from PyQt5.QtGui import *
    
    from lbp import Hog_descriptor
    
    from PyQt5.QtCore import *
    from PyQt5.QtGui import *
    from PyQt5.QtWidgets import *
    
    ###========全局变量 定义开始=======###
    # 打开的是摄像头还是本地视频
    camera_or_local_flag = 0
    # 识别进行中还是暂停识别中，1为摄像头，2位本地摄像头
    Start_or_pause_flag = 0
    
    GUI_SHOW_PICTURE_WIDTH=300
    GUI_SHOW_PICTURE_HEIGHT=300
    
    def getFigure(dst,n):
        if n == 1:
            number = 256
    
        if n == 2:
            number = 59
    
        rate = np.zeros((1, number))
        print("number == ",number)
        for row in range(0, dst.shape[0] - 1):
            for col in range(0, dst.shape[1] - 1):
                rate[0, dst[row, col]] = rate[0, dst[row, col]] + 1
    
        x = np.zeros(number)
        for i in range(1, number):
            x[i] = i
        plt.bar(x, rate[0, :], align='center')
    
        if n == 1:
            plt.savefig("lbp_pic.jpg")
            plt.show()
        if n == 2:
            plt.savefig("lbp_uniform_pic.jpg")
            plt.show()
    
        return
    
    def arry_58():
        l = np.zeros(58, dtype=int)
        m = []
        a = -1
        for i in range(256):
            bit = '{:08b}'.format(i)  # 二进制化
            arry = []  # 二进制生成数组
            count = 0  # 计数变化次数
            # 把字符串变为数组方便统计变化次数
            for x in range(len(bit)):
                arry.append(int(bit[x]))
            # print(arry)
            first = arry[0]  # 数组第一个为first，与之后的比较
            for j in range(1, len(arry)):
                if arry[j] != first:  # 如果变化，计数单位加1
                    count += 1
                    first = arry[j]  # 并且把变化的值重新赋值
            # print(count)
            if count <= 2:  # 如果变化次数小于2，则依次排序
                a += 1
                # print(i)
                l[a] = i
        return l
    
    def getHopTimes(data):
        """ 获取跳变次数，此函数为 uniform_LBP() 函数服务 :param data: :return: """
        count = 0
        binaryCode = "{0:0>8b}".format(data)
        for i in range(1, len(binaryCode)):
            if binaryCode[i] != binaryCode[(i - 1)]:
                count += 1
        return count
    
    def LBP_Cal(src,y):
        dst = np.zeros(src.shape,dtype = src.dtype)
        l = arry_58()  # 获取位置
        for row in range(1,src.shape[0]-1):
            for col in range(1,src.shape[1]-1):
                center = src[row,col]
                LBPtemp = 0
    
                LBPtemp |= (src[row-1,col-1] >= center) << 7
                LBPtemp |= (src[row-1,col  ] >= center) << 6
                LBPtemp |= (src[row-1,col+1] >= center) << 5
                LBPtemp |= (src[row  ,col-1] >= center) << 4
                LBPtemp |= (src[row  ,col+1] >= center) << 3
                LBPtemp |= (src[row+1,col-1] >= center) << 2
                LBPtemp |= (src[row+1,col  ] >= center) << 1
                LBPtemp |= (src[row+1,col+1] >= center) << 0
    
                if y == 1:
                    dst[row,col] = LBPtemp
    
                if y == 2:
                    if getHopTimes(LBPtemp) >= 3:
                        dst[row, col] = 0
                    else:
                        for i in range(len(l)):
                            if l[i] == LBPtemp:
                                loca = i
                                break
                        dst[row, col] = loca
    
        return dst
    
    #RGB转HSL, 求亮度均值需要
    def rgbtohsi(rgb_lwpImg):
        rows = int(rgb_lwpImg.shape[0])
        cols = int(rgb_lwpImg.shape[1])
        B, G, R = cv.split(rgb_lwpImg)
        # 归一化到[0,1]
        B = B / 255.0
        G = G / 255.0
        R = R / 255.0
        hsi_lwpImg = rgb_lwpImg.copy()
        H, S, I = cv.split(hsi_lwpImg)
        for i in range(rows):
            for j in range(cols):
                num = 0.5 * ((R[i, j] - G[i, j]) + (R[i, j] - B[i, j]))
                den = np.sqrt((R[i, j] - G[i, j]) ** 2 + (R[i, j] - B[i, j]) * (G[i, j] - B[i, j]))
                theta = float(np.arccos(num / den))
    
                if den == 0:
                    H = 0
                elif B[i, j] <= G[i, j]:
                    H = theta
                else:
                    H = 2 * 3.14169265 - theta
    
                min_RGB = min(min(B[i, j], G[i, j]), R[i, j])
                sum = B[i, j] + G[i, j] + R[i, j]
                if sum == 0:
                    S = 0
                else:
                    S = 1 - 3 * min_RGB / sum
    
                H = H / (2 * 3.14159265)
                I = sum / 3.0
                # 输出HSI图像，扩充到255以方便显示，一般H分量在[0,2pi]之间，S和I在[0,1]之间
                hsi_lwpImg[i, j, 0] = H * 255
                hsi_lwpImg[i, j, 1] = S * 255
                hsi_lwpImg[i, j, 2] = I * 255
    
        return hsi_lwpImg
    
    #创建窗口
    class Ui_MainWindow(object):
    
        def setupUi(self, MainWindow):
            MainWindow.setObjectName("MainWindow")
            # 1、总界面框大小 MainWindow
            MainWindow.resize(1300, 820)  # 总界面框
            # 左边界面区域：verticalLayoutWidget QWidget类
            self.verticalLayoutWidget = QtWidgets.QWidget(MainWindow)
            self.verticalLayoutWidget.setGeometry(QtCore.QRect(50, 15, 300, 300))  # 左边图片框。左上角坐标及宽度高度
            self.verticalLayoutWidget.setStyleSheet('background-color:rgb(55,55,55)')  # 设置做左边框的颜色
            self.verticalLayoutWidget.setObjectName("verticalLayoutWidget")
            self.verticalLayout = QtWidgets.QVBoxLayout(self.verticalLayoutWidget)  # QVBoxLayout类 垂直地摆放小部件
            self.verticalLayout.setContentsMargins(0, 0, 0, 0)  # 设置左侧、顶部、右侧和底部边距，以便在布局周围使用。
            self.verticalLayout.setObjectName("verticalLayout")
            self.label_ShowPicture = QtWidgets.QLabel(self.verticalLayoutWidget)
            self.label_ShowPicture.setObjectName("label_ShowPicture")
            self.verticalLayout.addWidget(self.label_ShowPicture)
    
            self.verticalLayoutWidget_3 = QtWidgets.QWidget(MainWindow)
            self.verticalLayoutWidget_3.setGeometry(QtCore.QRect(10, 410, 300, 300))  # 左边图片框。左上角坐标及宽度高度
            self.verticalLayoutWidget_3.setStyleSheet('background-color:rgb(55,55,55)')  # 设置做左边框的颜色
            self.verticalLayoutWidget_3.setObjectName("verticalLayoutWidget_3")
            self.verticalLayout_3 = QtWidgets.QVBoxLayout(self.verticalLayoutWidget_3)  # QVBoxLayout类 垂直地摆放小部件
            self.verticalLayout_3.setContentsMargins(0, 0, 0, 0)  # 设置左侧、顶部、右侧和底部边距，以便在布局周围使用。
            self.verticalLayout_3.setObjectName("verticalLayout_3")
            self.label_ShowPicture_2 = QtWidgets.QLabel(self.verticalLayoutWidget_3)
            self.label_ShowPicture_2.setObjectName("label_ShowPicture_2")
            self.verticalLayout_3.addWidget(self.label_ShowPicture_2)
    
            self.verticalLayoutWidget_4 = QtWidgets.QWidget(MainWindow)
            self.verticalLayoutWidget_4.setGeometry(QtCore.QRect(335, 410, 300, 300))  # 左边图片框。左上角坐标及宽度高度
            self.verticalLayoutWidget_4.setStyleSheet('background-color:rgb(55,55,55)')  # 设置做左边框的颜色
            self.verticalLayoutWidget_4.setObjectName("verticalLayoutWidget_4")
            self.verticalLayout_4 = QtWidgets.QVBoxLayout(self.verticalLayoutWidget_4)  # QVBoxLayout类 垂直地摆放小部件
            self.verticalLayout_4.setContentsMargins(0, 0, 0, 0)  # 设置左侧、顶部、右侧和底部边距，以便在布局周围使用。
            self.verticalLayout_4.setObjectName("verticalLayout_4")
            self.label_ShowPicture_4 = QtWidgets.QLabel(self.verticalLayoutWidget_4)
            self.label_ShowPicture_4.setObjectName("label_ShowPicture_4")
            self.verticalLayout_4.addWidget(self.label_ShowPicture_4)
    
            self.verticalLayoutWidget_5 = QtWidgets.QWidget(MainWindow)
            self.verticalLayoutWidget_5.setGeometry(QtCore.QRect(660, 410, 300, 300))  # 左边图片框。左上角坐标及宽度高度
            self.verticalLayoutWidget_5.setStyleSheet('background-color:rgb(55,55,55)')  # 设置做左边框的颜色
            self.verticalLayoutWidget_5.setObjectName("verticalLayoutWidget_5")
            self.verticalLayout_5= QtWidgets.QVBoxLayout(self.verticalLayoutWidget_5)  # QVBoxLayout类 垂直地摆放小部件
            self.verticalLayout_5.setContentsMargins(0, 0, 0, 0)  # 设置左侧、顶部、右侧和底部边距，以便在布局周围使用。
            self.verticalLayout_5.setObjectName("verticalLayout_5")
            self.label_ShowPicture_5 = QtWidgets.QLabel(self.verticalLayoutWidget_5)
            self.label_ShowPicture_5.setObjectName("label_ShowPicture_5")
            self.verticalLayout_5.addWidget(self.label_ShowPicture_5)
    
            self.verticalLayoutWidget_6 = QtWidgets.QWidget(MainWindow)
            self.verticalLayoutWidget_6.setGeometry(QtCore.QRect(985, 410, 300, 300))  # 左边图片框。左上角坐标及宽度高度
            self.verticalLayoutWidget_6.setStyleSheet('background-color:rgb(55,55,55)')  # 设置做左边框的颜色
            self.verticalLayoutWidget_6.setObjectName("verticalLayoutWidget_6")
            self.verticalLayout_6 = QtWidgets.QVBoxLayout(self.verticalLayoutWidget_6)  # QVBoxLayout类 垂直地摆放小部件
            self.verticalLayout_6.setContentsMargins(0, 0, 0, 0)  # 设置左侧、顶部、右侧和底部边距，以便在布局周围使用。
            self.verticalLayout_6.setObjectName("verticalLayout_3")
            self.label_ShowPicture_6 = QtWidgets.QLabel(self.verticalLayoutWidget_6)
            self.label_ShowPicture_6.setObjectName("label_ShowPicture_6")
            self.verticalLayout_6.addWidget(self.label_ShowPicture_6)
    
            # 右边按钮及显示结果字符的一块区域：verticalLayoutWidget_2 QWidget类
            self.verticalLayoutWidget_1 = QtWidgets.QWidget(MainWindow)
            self.verticalLayoutWidget_1.setGeometry(QtCore.QRect(450, 0, 750, 400))  # 右边按钮及显示结果字符的大小
            #self.verticalLayoutWidget_1.setStyleSheet('background-color:rgb(155,155,155)') # 设置做左边框的颜色
            self.layout_1 = QtWidgets.QGridLayout(self.verticalLayoutWidget_1)  # QGridLayout类别 窗口布局,将layout_1 布置到 verticalLayoutWidget_1
            self.layout_1.setContentsMargins(0, 0, 0, 0)#4个参数顺序是左上右下.作用：设置左侧、顶部、右侧和底部边距，以便在布局周围使用。
            self.layout_1.setObjectName("QGridLayout_1")
    
            mianjiLabel = QLabel("面积:")
            self.mianjiLineEdit = QLineEdit(" ")
            zhouchangLabel = QLabel("周长:")
            self.zhouchangLineEdit = QLineEdit(" ")
            xingxinLabel = QLabel("形心:")
            self.xingxinLineEdit = QLineEdit("")
            changzhouLabel = QLabel("长轴:")
            self.changzhouLineEdit = QLineEdit("")
            duanzhouLabel = QLabel("短轴:")
            self.duanzhouEdit = QLineEdit("")
            zuidakuaduLabel = QLabel("最大跨度:")
            self.zuidakuaduEdit = QLineEdit("")
            max_neiyuna_Label = QLabel("最大内切圆半径:")
            self.max_neiyuna_Edit = QLineEdit("")
            max_waiyuna_Label = QLabel("最小外接圆半径:")
            self.max_waiyuna_Edit = QLineEdit("")
            RatioChangDuanZhou = QLabel("长短轴之比:")
            self.RatioChangDuanZhou = QLineEdit("")
    
            R_ave_Label = QLabel("R均值:")
            self.R_ave_Edit = QLineEdit("")
            G_ave_Label = QLabel("G均值:")
            self.G_ave_Edit = QLineEdit("")
            B_ave_Label = QLabel("B均值:")
            self.B_ave_Edit = QLineEdit("")
    
            R_biaozhuncha_Label = QLabel("R标准差:")
            self.R_biaozhuncha_Edit = QLineEdit("")
            G_biaozhuncha_Label = QLabel("G标准差:")
            self.G_biaozhuncha_Edit = QLineEdit("")
            B_biaozhuncha_Label = QLabel("B标准差:")
            self.B_biaozhuncha_Edit = QLineEdit("")
    
            L_ave_Label = QLabel("亮度均值:")
            self.L_ave_Edit = QLineEdit("")
            L_biaozhuncha_Label = QLabel("亮度标准差:")
            self.L_biaozhuncha_Label = QLineEdit("")
    
            Hu_1 = QLabel("Hu矩_1:")
            self.Hu_1 = QLineEdit("")
            Hu_2 = QLabel("Hu矩_2:")
            self.Hu_2 = QLineEdit("")
            Hu_3 = QLabel("Hu矩_3:")
            self.Hu_3 = QLineEdit("")
            Hu_4 = QLabel("Hu矩_4:")
            self.Hu_4 = QLineEdit("")
            Hu_5 = QLabel("Hu矩_5:")
            self.Hu_5 = QLineEdit("")
            Hu_6 = QLabel("Hu矩_6:")
            self.Hu_6 = QLineEdit("")
            Hu_7 = QLabel("Hu矩_7:")
            self.Hu_7 = QLineEdit("")
    
            self.layout_1.addWidget(mianjiLabel,1,0)  # 将按钮1增加到
            self.layout_1.addWidget(self.mianjiLineEdit,1,1)
            self.layout_1.addWidget(zhouchangLabel, 2, 0)
            self.layout_1.addWidget(self.zhouchangLineEdit, 2, 1)
            self.layout_1.addWidget(xingxinLabel,3,0)
            self.layout_1.addWidget(self.xingxinLineEdit,3,1)
            self.layout_1.addWidget(changzhouLabel,4,0)
            self.layout_1.addWidget(self.changzhouLineEdit,4,1)
            self.layout_1.addWidget(duanzhouLabel,1,2)
            self.layout_1.addWidget(self.duanzhouEdit,1,3)
            self.layout_1.addWidget(zuidakuaduLabel,2,2)
            self.layout_1.addWidget(self.zuidakuaduEdit,2,3)
            self.layout_1.addWidget(max_neiyuna_Label,3,2)
            self.layout_1.addWidget(self.max_neiyuna_Edit,3,3)
            self.layout_1.addWidget(max_waiyuna_Label,4,2)
            self.layout_1.addWidget(self.max_waiyuna_Edit,4,3)
    
            self.layout_1.addWidget(R_ave_Label,1,4)
            self.layout_1.addWidget(self.R_ave_Edit,1,5)
            self.layout_1.addWidget(G_ave_Label,2,4)
            self.layout_1.addWidget(self.G_ave_Edit,2,5)
            self.layout_1.addWidget(B_ave_Label,3,4)
            self.layout_1.addWidget(self.B_ave_Edit,3,5)
            self.layout_1.addWidget(L_ave_Label,4,4)
            self.layout_1.addWidget(self.L_ave_Edit,4,5)
    
            self.layout_1.addWidget(R_biaozhuncha_Label,1,6)
            self.layout_1.addWidget(self.R_biaozhuncha_Edit,1,7)
            self.layout_1.addWidget(G_biaozhuncha_Label,2,6)
            self.layout_1.addWidget(self.G_biaozhuncha_Edit,2,7)
            self.layout_1.addWidget(B_biaozhuncha_Label,3,6)
            self.layout_1.addWidget(self.B_biaozhuncha_Edit,3,7)
            self.layout_1.addWidget(L_biaozhuncha_Label,4,6)
            self.layout_1.addWidget(self.L_biaozhuncha_Label,4,7)
    
            self.layout_1.addWidget(RatioChangDuanZhou, 5, 0)
            self.layout_1.addWidget(self.RatioChangDuanZhou, 5, 1)
    
            self.layout_1.addWidget(Hu_1, 5, 2)
            self.layout_1.addWidget(self.Hu_1, 5, 3)
            self.layout_1.addWidget(Hu_2, 5, 4)
            self.layout_1.addWidget(self.Hu_2, 5, 5)
            self.layout_1.addWidget(Hu_3, 5, 6)
            self.layout_1.addWidget(self.Hu_3, 5, 7)
            self.layout_1.addWidget(Hu_4, 6, 0)
            self.layout_1.addWidget(self.Hu_4, 6, 1)
            self.layout_1.addWidget(Hu_5, 6, 2)
            self.layout_1.addWidget(self.Hu_5, 6, 3)
            self.layout_1.addWidget(Hu_6, 6, 4)
            self.layout_1.addWidget(self.Hu_6, 6, 5)
            self.layout_1.addWidget(Hu_7, 6, 6)
            self.layout_1.addWidget(self.Hu_7, 6, 7)
    
            # 下拉菜单
            self.menubar = QtWidgets.QMenuBar(MainWindow)
            self.menubar.setGeometry(QtCore.QRect(0, 0, 800, 22))
            self.menubar.setObjectName("menubar")
            # 文件
            self.menu0 = QtWidgets.QMenu(self.menubar)
            MainWindow.setMenuBar(self.menubar)
            self.statusbar = QtWidgets.QStatusBar(MainWindow)
            MainWindow.setStatusBar(self.statusbar)
            self.action01 = QtWidgets.QAction(MainWindow)
            self.menu0.addAction(self.action01)
            self.menubar.addAction(self.menu0.menuAction())
            # 图像处理
            self.menu1 = QtWidgets.QMenu(self.menubar)
            self.action11 = QtWidgets.QAction(MainWindow)
            self.action12 = QtWidgets.QAction(MainWindow)
            self.action13 = QtWidgets.QAction(MainWindow)
            self.menu1.addAction(self.action11)
            self.menu1.addAction(self.action12)
            self.menu1.addAction(self.action13)
            self.menubar.addAction(self.menu1.menuAction())
            # 特征提取
            self.menu2 = QtWidgets.QMenu(self.menubar)
            self.action21 = QtWidgets.QAction(MainWindow)
            self.action22 = QtWidgets.QAction(MainWindow)
            self.action23 = QtWidgets.QAction(MainWindow)
            self.menu2.addAction(self.action21)
            self.menu2.addAction(self.action22)
            self.menu2.addAction(self.action23)
            self.menubar.addAction(self.menu2.menuAction())
            # 纹理特征
            self.menu3 = QtWidgets.QMenu(self.menubar)
            self.action31 = QtWidgets.QAction(MainWindow)
            self.action32 = QtWidgets.QAction(MainWindow)
            self.action33 = QtWidgets.QAction(MainWindow)
            self.menu3.addAction(self.action31)
            self.menu3.addAction(self.action32)
            self.menu3.addAction(self.action33)
            self.menubar.addAction(self.menu3.menuAction())
            # 其他
            self.menu4 = QtWidgets.QMenu(self.menubar)
            self.action41 = QtWidgets.QAction(MainWindow)
            self.action42 = QtWidgets.QAction(MainWindow)
            self.menu4.addAction(self.action41)
            self.menu4.addAction(self.action42)
            self.menubar.addAction(self.menu4.menuAction())
    
            self.retranslateUi(MainWindow)
    
            # 建立通信连接
            self.action01.triggered.connect(self.select_pcture_click)
            self.action01.setShortcut('Ctrl+F')
    
            self.action11.triggered.connect(lambda: self.yuchuli(1))
            self.action12.triggered.connect(lambda: self.yuchuli(2))
            self.action13.triggered.connect(lambda: self.yuchuli(3))
    
            self.action21.triggered.connect(lambda: self.some_feture(1))
            self.action22.triggered.connect(lambda: self.some_feture(2))
            self.action23.triggered.connect(lambda: self.some_feture(3))
    
            self.action31.triggered.connect(lambda: self.wenli(1))
            self.action32.triggered.connect(lambda: self.wenli(2))
            self.action33.triggered.connect(lambda: self.wenli(3))
    
            self.action41.triggered.connect(lambda: self.help(1))
            self.action42.triggered.connect(lambda: self.help(2))
    
    
    
    
    
        def retranslateUi(self, MainWindow):
            _translate = QtCore.QCoreApplication.translate
            MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
    
            self.menu0.setTitle(_translate("MainWindow", "文件"))
            self.action01.setText(_translate("MainWindow", "选择图片"))
    
            self.menu1.setTitle(_translate("MainWindow", "图像处理"))
            self.action11.setText(_translate("MainWindow", "灰度化"))
            self.action12.setText(_translate("MainWindow", "二值化"))
            self.action13.setText(_translate("MainWindow", "边缘提取"))
    
            self.menu2.setTitle(_translate("MainWindow", "特征提取"))
            self.action21.setText(_translate("MainWindow", "基本特征"))
            self.action22.setText(_translate("MainWindow", "颜色特征"))
            self.action23.setText(_translate("MainWindow", "不变矩特征"))
    
            self.menu3.setTitle(_translate("MainWindow", "纹理特征"))
            self.action31.setText(_translate("MainWindow", "LBP_1"))
            self.action32.setText(_translate("MainWindow", "LBP_2"))
            self.action33.setText(_translate("MainWindow", "HOG"))
    
            self.menu4.setTitle(_translate("MainWindow", "其他"))
            self.action41.setText(_translate("MainWindow", "用户手册"))
            self.action42.setText(_translate("MainWindow", "关于本系统"))
    
        image = None
    
        #选择图片
        def select_pcture_click(self):
            global camera_or_local_flag
    
            filename = QFileDialog.getOpenFileName(None, 'Open file', 'C:/Users/Desktop/testpicture/')#后面这个路径其实没什么用，路径主要还是看选择的具体路径
            # 设置标签的图片
            src0 = cv.imread(filename[0])
            [height_src0, width_src0,hhh]= src0.shape
            print('height_src0: %d \twidth_src0: %d \t' % (height_src0, width_src0))
    
            if (width_src0 > GUI_SHOW_PICTURE_WIDTH):
                print("1")
                rate1 = GUI_SHOW_PICTURE_WIDTH / width_src0
                print(GUI_SHOW_PICTURE_WIDTH)
                print(rate1)
                new_width = GUI_SHOW_PICTURE_WIDTH
                new_height = int(height_src0 * rate1)
                print(new_width, new_height)
    
                if (height_src0 > GUI_SHOW_PICTURE_HEIGHT):#图片宽高都大于1280*720
                    print("2")
                    rate2 = GUI_SHOW_PICTURE_HEIGHT /height_src0
                    if(rate2<rate1):#选择更宽或者更高的一个缩放到标准1280或者720,
                        rate2=rate2
                        new_height = GUI_SHOW_PICTURE_HEIGHT
                        new_width  = int(width_src0 * rate2)
                    else:
                        rate2=rate1
                        new_height = int(height_src0 * rate2)
                        new_width  = GUI_SHOW_PICTURE_WIDTH
                #image = src0.scaled(new_width, new_height)
                resized0 = cv.resize(src0, (new_width, new_height), interpolation=cv.INTER_AREA)
            elif (height_src0 > GUI_SHOW_PICTURE_HEIGHT):
                print("3")
                rate3 = GUI_SHOW_PICTURE_HEIGHT /height_src0
                print("rate3=",rate3)
                new_height = GUI_SHOW_PICTURE_HEIGHT
                new_width = int(width_src0 * rate3)
                print("new_height=", new_height)
                print("new_width=", new_width)
                #image = src0.scaled(new_width, new_height)
                resized0 = cv.resize(src0, (new_width, new_height), interpolation=cv.INTER_AREA)
            else:
                print("4")
                resized0 =src0
                new_width=width_src0
                new_height=height_src0
            #resized0 = cv.resize(src0, (1280, 720), interpolation=cv.INTER_AREA)
            cv.imwrite("temp0.jpg", resized0)
            self.label_ShowPicture.move(0, 0)
            print("new_height=", new_height)
            print("new_width=", new_width)
    
            self.label_ShowPicture.setPixmap(QPixmap("temp0.jpg"))
            print("filename[0]=",filename[0])
            self.image = Image.open(filename[0])
    
            camera_or_local_flag=3# 打开图像识别
    
        # 边缘、灰度、二值函数
        def yuchuli(self,i):
            if i == 0:
                print("yuchuli 0")
            if i == 1:
                print("yuchuli 1")
                img = cv.imread("temp0.jpg")
                gray = cv.cvtColor(img, cv.COLOR_RGB2GRAY)
                cv.imwrite("hui.jpg", gray)
                self.label_ShowPicture_4.setPixmap(QPixmap("hui.jpg"))
            if i == 2:
                print("yuchuli 2")
                gray = cv.imread("hui.jpg")
                ret, thresh1 = cv.threshold(gray, 125, 255, cv.THRESH_BINARY)
                # 填充
                kernel = cv.getStructuringElement(cv.MORPH_RECT, (25, 25))
                closed = cv.morphologyEx(thresh1, cv.MORPH_CLOSE, kernel)
                # 腐蚀膨胀
                closed = cv.erode(closed, None, iterations=2)
                closed = cv.dilate(closed, None, iterations=2)
    
                cv.imwrite("erzhi.jpg", closed)
                self.label_ShowPicture_4.setPixmap(QPixmap("erzhi.jpg"))
            if i == 3:
                print("yuchuli 3")
                image = cv.imread("erzhi.jpg")
                t = 140
                canny_output = cv.Canny(image, t, t * 2)
                cv.imwrite("contour.jpg", canny_output)
                self.label_ShowPicture_2.setPixmap(QPixmap("contour.jpg"))
    
        # 基本、颜色、不变矩特征
        def some_feture(self,j):
            i = int(0)
    
            self.frame = cv.imread("temp0.jpg")
            frame1 = cv.imread("contour.jpg")
            frame_src0 = self.frame.copy()
            print("***********图像处理 start******************************************************************")
            '''1、灰度化，二值化'''
            gray = cv.cvtColor(frame1, cv.COLOR_RGB2GRAY)
            ret, thresh1 = cv.threshold(gray, 125, 255, cv.THRESH_BINARY)
    
            '''2、找轮廓'''
            t = 140
            canny_output = cv.Canny(thresh1, t, t * 2)
            (cnts, _) = cv.findContours(canny_output, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
            c = sorted(cnts, key=cv.contourArea, reverse=True)[0]
            # cv.drawContours(frame1, contours, -1, (0, 0, 255), 1)
            # 5.2使用轮廓长度滤波
    
            if j == 0:
                print("soma_feture 0")
            if j == 1:
                print("soma_feture 1")
                # 1、面积
                area = 0
                height, width = thresh1.shape
                for i in range(height):
                    for j in range(width):
                        if thresh1[i, j] == 255:
                            area += 1
                minaji = height * width / 784
                # minaji=cv.contourArea(contours[0])
                minaji = "{:.2f}".format(minaji)  # 归一化格式
                self.mianjiLineEdit.setText(str(minaji))
                print("mianji")
                # 2、周长
                zhouchang = cv.arcLength(c, True)
                zhouchang = "{:.2f}".format(zhouchang)  # 归一化格式
                self.zhouchangLineEdit.setText(str(zhouchang))
                print("long")
                # 3、形心
                M = cv.moments(c)  # 计算图像矩
                cx = int(M['m10'] / M['m00'])  # 重心的x坐标
                cy = int(M['m01'] / M['m00'])  # 重心的y坐标
                cx = "{:.0f}".format(cx)  # 归一化格式
                cy = "{:.0f}".format(cy)  # 归一化格式
                center = (cx, cy)
                self.xingxinLineEdit.setText("(" + str(cx) + "," + str(cy) + ")")
                print("xingxin")
                # 4、 最小包围圆
                (x, y), radius = cv.minEnclosingCircle(c)
                center = (int(x), int(y))
                radius = int(radius)
                cv.circle(frame1, center, radius, (0, 255, 0), 2)
                print("半径：", radius)
                radius = "{:.2f}".format(radius)  # 归一化格式
                self.max_waiyuna_Edit.setText(str(radius))
                print("nwaiqieyuan")
                # 最大内接圆
                # Calculate the distances to the contour
                # 这里计算轮廓点直接距离得用找轮廓时的二值化图像大小来求
                raw_dist = np.empty(thresh1.shape, dtype=np.float32)
                for i in range(thresh1.shape[0]):
                    for j in range(thresh1.shape[1]):
                        raw_dist[i, j] = cv.pointPolygonTest(c, (j, i), True)
                # 获取最大值即内接圆半径maxVal，中心点坐标maxDistPt
                minVal, maxVal, _, maxDistPt = cv.minMaxLoc(raw_dist)
                maxVal = abs(maxVal)  # 最大内接圆半径
                cv.circle(frame1, maxDistPt, np.int(maxVal), (0, 255, 0), 2, cv.LINE_8, 0)
                maxVal = "{:.2f}".format(maxVal)  # 归一化格式
                self.max_neiyuna_Edit.setText(str(maxVal))
                print("niejie")
                # 拟合椭圆，求短轴长轴
                ellipse = cv.fitEllipse(c)
                cv.ellipse(frame1, ellipse, (255, 255, 0), 2)
                # fit contour to ellipse and get ellipse center, minor and major diameters and angle in degree
                (xc, yc), (duanzhou, changzhou), angle = ellipse  # 值分别是椭圆中心，短轴，长轴，以及角度
                print(xc, yc, duanzhou, changzhou, angle)
                x = duanzhou / changzhou
                duanzhou = "{:.2f}".format(duanzhou)  # 归一化格式
                changzhou = "{:.2f}".format(changzhou)  # 归一化格式
                self.duanzhouEdit.setText(str(duanzhou))
                self.changzhouLineEdit.setText(str(changzhou))
    
                # 最小外接矩形，矩形和椭圆拟合关联较大，Rotate Rectangle
                rect = cv.minAreaRect(c)
                box = np.int0(cv.boxPoints(rect))
                cv.drawContours(frame1, [box], 0, (0, 0, 255), 2)
                zuidakuadu = "{:.2f}".format(rect[1][0])  # 归一化格式
                self.zuidakuaduEdit.setText(str(zuidakuadu))
    
                # 长短轴之比
                x = "{:.2f}".format(x)
                self.RatioChangDuanZhou.setText(str(x))
    
                # 可视化效果显示在 1 框中
                height, width, bytesPerComponent = frame1.shape  # 取彩色图片的长、宽、通道
                bytesPerLine = 3 * width
                QImg = QImage(frame1.data, width, height, bytesPerLine, QImage.Format_RGB888)
                pixmap = QPixmap.fromImage(QImg)
                self.label_ShowPicture_2.setPixmap(QPixmap(pixmap))
    
            # 颜色特征
            if j == 2:
                print("soma_feture 2")
                # RGB均值及标准差
                R_mean = frame_src0[:, :, 0].mean()
                G_mean = frame_src0[:, :, 1].mean()
                B_mean = frame_src0[:, :, 2].mean()
    
                R_std = frame_src0[:, :, 0].std()
                G_std = frame_src0[:, :, 1].std()
                B_std = frame_src0[:, :, 2].std()
    
                R_mean = "{:.2f}".format(R_mean)  # 归一化格式
                self.R_ave_Edit.setText(str(R_mean))
                G_mean = "{:.2f}".format(G_mean)  # 归一化格式
                self.G_ave_Edit.setText(str(G_mean))
                B_mean = "{:.2f}".format(B_mean)  # 归一化格式
                self.B_ave_Edit.setText(str(B_mean))
    
                R_std = "{:.2f}".format(R_std)  # 归一化格式
                self.R_biaozhuncha_Edit.setText(str(R_std))
                G_std = "{:.2f}".format(G_std)  # 归一化格式
                self.G_biaozhuncha_Edit.setText(str(G_std))
                B_std = "{:.2f}".format(B_std)  # 归一化格式
                self.B_biaozhuncha_Edit.setText(str(B_std))
                print("RGB均值：")
                print(frame_src0[:, :, 0].mean())  # r
                print(frame_src0[:, :, 1].mean())  # g
                print(frame_src0[:, :, 2].mean())  # b
                print("RGB标准差：")
                print(frame_src0[:, :, 0].std())  # r
                print(frame_src0[:, :, 1].std())  # g
                print(frame_src0[:, :, 2].std())  # b
    
                [height_src0, width_src0, hhh] = frame_src0.shape
                num = height_src0 * width_src0  # 这里宽高是每幅图片的大小
    
                hsi_lwpImg = rgbtohsi(frame_src0)
                L_channel_mean = hsi_lwpImg[:, :, 2].mean()  # L
                L_channel_std = hsi_lwpImg[:, :, 2].std()  # L
                L_channel_mean = "{:.2f}".format(L_channel_mean)  # 归一化格式
                self.L_ave_Edit.setText(str(L_channel_mean))
                L_channel_std = "{:.2f}".format(L_channel_std)  # 归一化格式
                self.L_biaozhuncha_Label.setText(str(L_channel_std))
    
            # 不变矩特征
            if j == 3:
                print("soma_feture 3")
                img = cv.imread("temp0.jpg")
                img_gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
                moments = cv.moments(img_gray)
                humoments = cv.HuMoments(moments)
                self.Hu_1.setText(str(humoments[0]))
                self.Hu_2.setText(str(humoments[1]))
                self.Hu_3.setText(str(humoments[2]))
                self.Hu_4.setText(str(humoments[3]))
                self.Hu_5.setText(str(humoments[4]))
                self.Hu_6.setText(str(humoments[5]))
                self.Hu_7.setText(str(humoments[6]))
    
            print("***********图像处理 end ******************************************************************")
    
        def wenli(self,z):
            src_ori = cv.imread("temp0.jpg")
            src = cv.cvtColor(src_ori, cv.COLOR_RGB2GRAY)
            if z == 1:
                dst = LBP_Cal(src,1)
                cv.imwrite("lbp.jpg", dst)
                self.label_ShowPicture_5.setPixmap(QPixmap("lbp.jpg"))
                getFigure(dst,1)
    
            if z == 2:
                dst = LBP_Cal(src,2)
                cv.imwrite("lbp_uniform.jpg", dst)
                self.label_ShowPicture_5.setPixmap(QPixmap("lbp_uniform.jpg"))
                getFigure(dst, 2)
    
            if z == 3:
                img = cv.imread('temp0.jpg', cv.IMREAD_GRAYSCALE)
                hog = Hog_descriptor(img, cell_size=8, bin_size=8)
                vector, image = hog.extract()
                print(np.array(vector).shape)
                cv.imwrite("test_hog.jpg", image)
                self.label_ShowPicture_6.setPixmap(QPixmap("test_hog.jpg"))
    
    
        def help(self,z):
            if z == 1:
                f1 = open("用户手册.txt", "r")  # 设置文件对象
                str1 = f1.read()  # 将txt文件的所有内容读入到字符串str中
                f1.close()  # 将文件关闭
                QMessageBox.about(self.verticalLayoutWidget_1, "用户手册",str1)
                #QMessageBox.about(self.verticalLayoutWidget_1, "用户手册", "用户手册.txt ")
            if z == 2:
                f2 = open("关于本系统.txt", "r")  # 设置文件对象
                str2 = f2.read()  # 将txt文件的所有内容读入到字符串str中
                f2.close()  # 将文件关闭
                QMessageBox.about(self.verticalLayoutWidget_1, "关于本系统", str2)
                #QMessageBox.about(self.verticalLayoutWidget_1, "关于本系统", "关于本系统.txt ")
    
    
    if __name__ == "__main__":
    
    
        app = QtWidgets.QApplication(sys.argv)
        MainWindow = QtWidgets.QMainWindow()
        ui = Ui_MainWindow()
        ui.setupUi(MainWindow)
        MainWindow.show()
        sys.exit(app.exec_())

# lbp.py #

import cv2
    import numpy as np
    import math
    import matplotlib.pyplot as plt
    
    
    class Hog_descriptor():
        def __init__(self, img, cell_size=16, bin_size=8):
            self.img = img
            self.img = np.sqrt(img / np.max(img))
            self.img = img * 255
            self.cell_size = cell_size
            self.bin_size = bin_size
            self.angle_unit = 360 // self.bin_size
            assert type(self.bin_size) == int,    "bin_size should be integer,"
            assert type(self.cell_size) == int,   "cell_size should be integer,"
            assert type(self.angle_unit) == int,  "bin_size should be divisible by 360"
    
        def extract(self):
            height, width = self.img.shape
            gradient_magnitude, gradient_angle = self.global_gradient()
            gradient_magnitude = abs(gradient_magnitude)
    
            cell_gradient_vector = np.zeros((height // self.cell_size, width // self.cell_size, self.bin_size))
            for i in range(cell_gradient_vector.shape[0]):
                for j in range(cell_gradient_vector.shape[1]):
                    cell_magnitude = gradient_magnitude[i * self.cell_size:(i + 1) * self.cell_size,
                                     j * self.cell_size:(j + 1) * self.cell_size]
                    cell_angle = gradient_angle[i * self.cell_size:(i + 1) * self.cell_size,
                                 j * self.cell_size:(j + 1) * self.cell_size]
                    cell_gradient_vector[i][j] = self.cell_gradient(cell_magnitude, cell_angle)
    
            hog_image = self.render_gradient(np.zeros([height, width]), cell_gradient_vector)
    
            hog_vector = []
            for i in range(cell_gradient_vector.shape[0] - 1):
                for j in range(cell_gradient_vector.shape[1] - 1):
                    block_vector = []
                    block_vector.extend(cell_gradient_vector[i][j])
                    block_vector.extend(cell_gradient_vector[i][j + 1])
                    block_vector.extend(cell_gradient_vector[i + 1][j])
                    block_vector.extend(cell_gradient_vector[i + 1][j + 1])
                    mag = lambda vector: math.sqrt(sum(i ** 2 for i in vector))
                    magnitude = mag(block_vector)
                    if magnitude != 0:
                        normalize = lambda block_vector, magnitude: [element // magnitude for element in block_vector]
                        block_vector = normalize(block_vector, magnitude)
                    hog_vector.append(block_vector)
            return hog_vector, hog_image
    
        def global_gradient(self):
            gradient_values_x = cv2.Sobel(self.img, cv2.CV_64F, 1, 0, ksize=5)
            gradient_values_y = cv2.Sobel(self.img, cv2.CV_64F, 0, 1, ksize=5)
            gradient_magnitude = cv2.addWeighted(gradient_values_x, 0.5, gradient_values_y, 0.5, 0)
            gradient_angle = cv2.phase(gradient_values_x, gradient_values_y, angleInDegrees=True)
            return gradient_magnitude, gradient_angle
    
        # 每个细胞单元构建梯度方向直方图
        def cell_gradient(self, cell_magnitude, cell_angle):
            orientation_centers = [0] * self.bin_size
            for i in range(cell_magnitude.shape[0]):
                for j in range(cell_magnitude.shape[1]):
                    gradient_strength = cell_magnitude[i][j]
                    gradient_angle = cell_angle[i][j]
                    min_angle, max_angle, mod = self.get_closest_bins(gradient_angle)
                    orientation_centers[min_angle] += (gradient_strength * (1 - (mod / self.angle_unit)))
                    orientation_centers[max_angle] += (gradient_strength * (mod / self.angle_unit))
            return orientation_centers
    
        def get_closest_bins(self, gradient_angle):
            idx = int(gradient_angle / self.angle_unit)
            mod = gradient_angle % self.angle_unit
            return idx, (idx + 1) % self.bin_size, mod
    
        def render_gradient(self, image, cell_gradient):
            cell_width = self.cell_size / 2
            max_mag = np.array(cell_gradient).max()
            for x in range(cell_gradient.shape[0]):
                for y in range(cell_gradient.shape[1]):
                    cell_grad = cell_gradient[x][y]
                    cell_grad /= max_mag
                    angle = 0
                    angle_gap = self.angle_unit
                    for magnitude in cell_grad:
                        angle_radian = math.radians(angle)
                        x1 = int(x * self.cell_size + magnitude * cell_width * math.cos(angle_radian))
                        y1 = int(y * self.cell_size + magnitude * cell_width * math.sin(angle_radian))
                        x2 = int(x * self.cell_size - magnitude * cell_width * math.cos(angle_radian))
                        y2 = int(y * self.cell_size - magnitude * cell_width * math.sin(angle_radian))
                        cv2.line(image, (y1, x1), (y2, x2), int(255 * math.sqrt(magnitude)))
                        angle += angle_gap
            return image
    
    ''''' img = cv2.imread('temp0.jpg', cv2.IMREAD_GRAYSCALE) hog = Hog_descriptor(img, cell_size=8, bin_size=8) vector, image = hog.extract() print (np.array(vector).shape) plt.imshow(image, cmap=plt.cm.gray) cv2.imwrite("test_hog.jpg",image) plt.show() '''

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hb19odWlfZmVp_size_16_color_FFFFFF_t_70]: /images/20221022/5a7556c605c746d4af1d20701a1c41ac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hb19odWlfZmVp_size_16_color_FFFFFF_t_70 1]: /images/20221022/fd24a3f2fbd94af09a72764719f0a8bd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hb19odWlfZmVp_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20210331154156770.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hb19odWlfZmVp,size_16,color_FFFFFF,t_70#pic_center