机器视觉编程作业02（01）（原创）

背景：机器视觉课堂编程作业之二

功能：实现边界检测、直线检测、圆检测

使用平台：python36　　opencv34

注意事项：python36下的opencv34出现了一些函数的用法变动

总体效果还是很好的。

显示效果：

源代码：

#-*- coding:utf-8 -*-
#edited by Mufasa

import tkinter as tk
import tkinter.filedialog
from PIL import Image, ImageTk
import numpy as np
from  tkinter import ttk
import time,threading
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from tkinter import messagebox
import cv2
import os

class main_:
    # def ui_():
        
    def btn_begin():
        global root
        btn_select = tk.Button(root,text='打开文件',width=15,command=assist.select).grid(row=0,column=0)
        btn_about = tk.Button(root,text='关于程序',width=15,command=assist.about).grid(row=0,column=4)
    def show_photo():
        global root
        label = tk.Label(root)
    def btn_then():
        global root
        btn_about = tk.Button(root,text='显示灰度原图',width=15,command=assist.show_gray).grid(row=0,column=1)
        btn_about = tk.Button(root,text='数据还原',width=15,command=assist.restart).grid(row=0,column=2)
        btn_about = tk.Button(root,text='当前图像保存',width=15,command=assist.storage).grid(row=0,column=3)
        
        btn_about = tk.Button(root,text='高斯滤波',width=15,command=filter.GaussianBlur).grid(row=1,column=0)
        btn_about = tk.Button(root,text='均值滤波',width=15,command=filter.MeanBlur).grid(row=1,column=1)
        btn_about = tk.Button(root,text='中值滤波',width=15,command=filter.medianBlur).grid(row=1,column=2)
        btn_about = tk.Button(root,text='双边滤波',width=15,command=filter.bilateralFilter).grid(row=1,column=3)
        btn_about = tk.Button(root,text='2d滤波器',width=15,command=filter.filter2D).grid(row=1,column=4)
        
        btn_about = tk.Button(root,text='laplacian',width=15,command=algorithm.laplacian).grid(row=2,column=0)
        btn_about = tk.Button(root,text='canny',width=15,command=algorithm.canny).grid(row=2,column=1)
        btn_about = tk.Button(root,text='形态学',width=15,command=algorithm.morphology).grid(row=2,column=2)
        btn_about = tk.Button(root,text='sobel算子',width=15,command=algorithm.sobel).grid(row=2,column=3)
        btn_about = tk.Button(root,text='检测原理解释',width=15,command=assist.describe_edge).grid(row=2,column=4)
        
        
        btn_about = tk.Button(root,text='梯度模型1',width=15,command=lambda:algorithm.gradient(n=0)).grid(row=3,column=0)
        btn_about = tk.Button(root,text='梯度模型2',width=15,command=lambda:algorithm.gradient(n=1)).grid(row=3,column=1)
        btn_about = tk.Button(root,text='梯度模型3',width=15,command=lambda:algorithm.gradient(n=2)).grid(row=3,column=2)
        btn_about = tk.Button(root,text='梯度模型4',width=15,command=lambda:algorithm.gradient(n=3)).grid(row=3,column=3)
        btn_about = tk.Button(root,text='梯度算法介绍',width=15,command=assist.describe_gradient).grid(row=3,column=4)
        
        btn_about = tk.Button(root,text='霍夫曼直线',width=15,command=algorithm.HoughLines).grid(row=4,column=0)
        btn_about = tk.Button(root,text='概率霍夫曼直线',width=15,command=algorithm.HoughLinesP).grid(row=4,column=1)
        btn_about = tk.Button(root,text='霍夫曼圆检测',width=15,command=algorithm.HoughCircles).grid(row=4,column=2)
        btn_about = tk.Button(root,text='直方图谱',width=15,command=assist._2D_out).grid(row=4,column=3)
        btn_about = tk.Button(root,text='3D图谱显示',width=15,command=assist._3D_out).grid(row=4,column=4)
        
        
        
class assist:
    def select():
        global data,path,im            #data是图像的灰度值
        path = tkinter.filedialog.askopenfilename(initialdir = '',filetypes=( ("Audio files", "*.jpg;*.bmp"),("All files", "*.*")))
        
        image = Image.open(path)
        im = ImageTk.PhotoImage(image)
        tk.Label(root, image = im).grid(row=5,column=0,columnspan=5)
        
        data = cv2.imdecode(np.fromfile(path,dtype=np.uint8),-1)
        if len(data.shape) >= 3:
            data = cv2.cvtColor(data,cv2.COLOR_BGR2GRAY)
        main_.btn_then()
        
    def show_gray():
        global data
        cv2.imshow(u"original", data)
        cv2.waitKey()
        cv2.destroyAllWindows()
        
    def _3D_out():
        global data
        fig = plt.figure()
        ax = Axes3D(fig)
        x = [i for i in range(len(data[0]))]
        y = [j for j in range(len(data))]

        X = np.mat(x)
        Y = np.mat(y)
        X, Y = np.meshgrid(X, Y)    #变成二维矩阵
        Z = np.mat(data)
        ax.plot_surface(X, Y, Z, rstride=5, cstride=5, cmap='rainbow')
        plt.show()
        
    def _2D_out():
        global data
        d_array = [0]*256
        for i in data:
            for j in i:
                d_array[j] = d_array[j] + 1
        plt.title(u"Ash rectangle",fontsize=24)
        plt.xlabel("Ash values",fontsize=10)
        plt.ylabel("Numbers",fontsize=10)
        plt.plot(d_array,linewidth=1)
        plt.show()
        
    def restart():
        global data
        data = cv2.imdecode(np.fromfile(path,dtype=np.uint8),-1)
        if len(data.shape) >= 3:
            data = cv2.cvtColor(data,cv2.COLOR_BGR2GRAY)
        
    def about():
        tk.messagebox.showinfo(title='关于程序', message=(
        '程序名称：边界检测
程序平台：python3.6、opencv3.4
编辑者：Mufasa
编辑时间：2017.12.24

主要功能：
1）灰度直方图、3D图谱显示；
2）高斯、均值、中值、双边、2d滤波器滤波；
3）Laplacian、Canny、形态学方法、sobel方法；
4）霍夫线变换、概率霍夫变换、霍夫圆变换；'
        ))
        
    def describe_edge():
        tk.messagebox.showinfo(title='算法简析', message=('Laplacian算法：计算灰度各个方向变化的二阶导数，将二阶导数的0值设置为边界
Canny算法：去噪声、计算梯度幅值和方向、进行非极大值抑制
形态学方法：将分别腐蚀和膨胀之后的图片进行相减处理
sobel算子：应用sobel算子对灰度图像进行卷积处理'))
        
    def describe_gradient():
        tk.messagebox.showinfo(title='梯度算法', message=('梯度算法:
1）原理与sobel算子基本一致
2）可以分为垂直水平和45度135度角的两种方向
3）差值的取和方式分为算术和取最大值两种等多种形式'))
        
    def storage():
        global data,path,name
        p,f=os.path.split(path)
        # print(p)
        num = os.path.splitext(str(time.time()))[0]
        # print(num)
        # print(name)
        # cv2.imwrite(p+'\'+name+'\'+num+'.jpg', data)    #python3版本下无法使用
        cv2.imencode('.jpg', data)[1].tofile(p+'//'+name+"_"+num+'.jpg')
        
        
class filter:
    def GaussianBlur():        #高斯滤波
        global data,name
        data = cv2.GaussianBlur(data,(5,5),0)
        cv2.imshow(u"GaussianBlur", data)
        name = "GaussianBlur"
        cv2.waitKey()
        cv2.destroyAllWindows()
        
    def MeanBlur():        #均值滤波
        global data,name
        data = cv2.blur(data,(3,5))
        cv2.imshow(u"MeanBlur", data)
        name = "MeanBlur"
        cv2.waitKey()
        cv2.destroyAllWindows()
        
    def filter2D():        #2D滤波器
        global data,name
        name = "filter2D"
        kernel = np.ones((5,5),np.float32)/25
        data = cv2.filter2D(data,-1,kernel)
        cv2.imshow(u"filter2D", data)
        cv2.waitKey()
        cv2.destroyAllWindows()
        
    def bilateralFilter():        #双边滤波
        global data,name
        name = "bilateralFilter"
        data = cv2.bilateralFilter(data,9,75,75)
        cv2.imshow(u"bilateralFilter", data)
        cv2.waitKey()
        cv2.destroyAllWindows()
        
    def medianBlur():        #中值滤波
        global data,name
        name = "medianBlur"
        
        data = cv2.medianBlur(data,5)
        cv2.imshow(u"medianBlur", data)
        cv2.waitKey()
        cv2.destroyAllWindows()
        
class algorithm:
    def laplacian():
        global data,name
        name = "laplacian"
        gray_lap = cv2.Laplacian(data,cv2.CV_16S,ksize = 3)
        data = cv2.convertScaleAbs(gray_lap)
        cv2.imshow('laplacian',data)
        cv2.waitKey()
        cv2.destroyAllWindows()
        
    def canny():
        global data,name
        name = "canny"
        data = cv2.Canny(data, 50, 100)
        cv2.imshow('canny',data)
        cv2.waitKey()
        cv2.destroyAllWindows()
    
    def morphology():        #形态学边界检测，膨胀和腐蚀后的图片相减
        global data,name
        name = "morphology"
        element = cv2.getStructuringElement(cv2.MORPH_RECT,(3,3))  
        dilate = cv2.dilate(data, element)      # 扩大；膨胀；详述
        erode = cv2.erode(data, element)      # 腐蚀，侵蚀
        data = cv2.absdiff(dilate,erode)
        cv2.imshow('morphology',data)
        cv2.waitKey()
        cv2.destroyAllWindows()
    
    def gradient(n):
        if n == 0:
            flag1,flag2 =0,0
        elif n == 1:
            flag1,flag2 =0,1
        elif n == 2:
            flag1,flag2 =1,0
        elif n == 3:
            flag1,flag2 =1,1
            
        global data,name
        name = "gradient"
        
        w = data.shape[0]
        h = data.shape[1]
        size = (w,h)    #(575, 768)
        iSharp = np.zeros(size, dtype='uint8')
        t = 3
        for i in range(0,w-t):    #高度减1！    #这里需要注意    i——（0,768-1-1=766）
            for j in range(0,h-t):            #宽度也减1        j——（0,575-1-1=573）
                if flag2 == 0:
                    x = abs(int(data[i,j+t])-int(data[i,j]))
                    y = abs(int(data[i+t,j])-int(data[i,j]))    #index 575 is out of bounds for axis 0 with size 575
                else:
                    x = abs(int(data[i+t,j+t])-int(data[i,j]))
                    y = abs(int(data[i+t,j])-int(data[i,j+t]))
                
                if flag1 == 0:
                    iSharp[i,j] = max(x,y)
                elif int(x)+int(y)>255:
                    iSharp[i,j] = 255            #内存溢出可能出现的地点
                else:
                    iSharp[i,j] = x+y
        data = iSharp
        cv2.imshow('gradient',data)
        cv2.waitKey()
        cv2.destroyAllWindows()
        
    def sobel():
        global data,name
        name = "sobel"
        
        x = cv2.Sobel(data,cv2.CV_16S,1,0)
        y = cv2.Sobel(data,cv2.CV_16S,0,1)
        absX = cv2.convertScaleAbs(x)# 转回uint8  
        absY = cv2.convertScaleAbs(y)
        data = cv2.addWeighted(absX,1,absY,1,0)
        cv2.imshow('sobel',data)
        cv2.waitKey()
        cv2.destroyAllWindows()
        
    def HoughLines():
        global data,name
        name = "HoughLines"
        
        img = cv2.GaussianBlur(data,(3,3),0)    #先进行高斯滤波，这里必须要先进行这一项
        img = cv2.Canny(img, 50, 150, apertureSize = 3)        #canny算子边界检测
        lines = cv2.HoughLines(img,1,np.pi/180,100) #这里对最后一个参数使用了经验型的值
        result = data.copy()
        for i in lines:
            for j in i:
                rho = j[0] #第一个元素是距离rho
                theta= j[1] #第二个元素是角度theta
            if  (theta < (np.pi/4. )) or (theta > (3.*np.pi/4.0)): #垂直直线
                pt1 = (int(rho/np.cos(theta)),0)
                #该直线与最后一行的焦点
                pt2 = (int((rho-result.shape[0]*np.sin(theta))/np.cos(theta)),result.shape[0])
                #绘制一条白线
                cv2.line( result, pt1, pt2, (255))
            else: #水平直线
                # 该直线与第一列的交点
                pt1 = (0,int(rho/np.sin(theta)))
                #该直线与最后一列的交点
                pt2 = (result.shape[1], int((rho-result.shape[1]*np.cos(theta))/np.sin(theta)))
                #绘制一条直线
                cv2.line(result, pt1, pt2, (255), 1)
        data = result
        cv2.imshow('HoughLines',data)
        cv2.waitKey()
        cv2.destroyAllWindows()
        
    def HoughLinesP():
        global data,name
        name = "HoughLinesP"
        
        edges = cv2.Canny(data, 50, 150, apertureSize = 3)  
        minLineLength = 60
        maxLineGap = 10
        lines = cv2.HoughLinesP(edges,1,np.pi/180,80,minLineLength,maxLineGap)  
        for i in lines:
            for x1,y1,x2,y2 in i:  
                cv2.line(data,(x1,y1),(x2,y2),(255),2)  
        cv2.imshow('HoughLinesP',data)
        cv2.waitKey()
        cv2.destroyAllWindows()
        
    def HoughCircles():
        global data,name
        name = "HoughCircles"
        
        edge = cv2.medianBlur(data, 5)
        circles = cv2.HoughCircles(edge, cv2.HOUGH_GRADIENT, 1, 120, param1=100, param2 = 30, minRadius = 0,  maxRadius = 0)
        circles = np.uint16(np.around(circles))
        for i in circles[0,:,:]:
            cv2.circle(data, (i[0], i[1]), i[2],(255),1)
            cv2.circle(data, (i[0], i[1]), 1, (255), 1)
        cv2.imshow("HoughCircles", data)
        cv2.waitKey()
        cv2.destroyAllWindows()
        
global data,path,root,name
name = 'original'

root = tk.Tk()
main_.btn_begin()
root.mainloop()

源程序及exe可执行程序链接

 链接：https://pan.baidu.com/s/1cptezW 密码：iukp