基于python3的图像卷积

      图像卷积就是通过一个卷积核对图像进行处理，不同的卷积核处理后的效果不同，根据实际需求选择不同的卷积核对图像进行处理。由于是直接编写的卷积核，以下代码只是为了帮助理解卷积，在数据量大的时候，卷积运行速度会很慢。

from scipy import signal
import numpy as np
from time import time
import cv2
def ImageToArray1(filename):
    image=cv2.imread(filename,cv2.IMREAD_GRAYSCALE)
    result2=np.array(image)#图片转换成二维数组
    result1=result2.flatten()#二维数组转换为一维数组
    return result1
result1=ImageToArray1("3600.jpg")
#print(cv2.imread("784.jpg",cv2.IMREAD_GRAYSCALE))
def ImageToArray2(filename):
    image=cv2.imread(filename,cv2.IMREAD_GRAYSCALE)
    result2=np.array(image)#图片转换成二维数组
    #result1=result2.flatten()#二维数组转换为一维数组
    return result2
result2=ImageToArray2("3600.jpg")

Kernel2=np.array([[1,2,3],[4,5,6],[7,8,9]])
Kernel1=np.array([1,0,-1,1,0,-1,1,0,-1])
    #([-1,0,1,-1,0,1,-1,0,1])

start2=time()
fullConv=signal.convolve2d(result2,Kernel2,mode='same',boundary='symm',fillvalue=0)
stop2=time()
print("二维卷积时间",str(stop2-start2)+"秒")
#print(fullConv)

def convolve2D(Image,Kernel):
    """
    #适用于输入时正方形的矩阵，化成的一维，卷积核是3*3的矩阵，化成一维
    :param Image:
    :param Kernel:
    :return:输出卷积后的结果，加过在数组的中心位置
    """
    start=time()
    X = int(np.sqrt(len(Image)))
    K = int(np.sqrt(len(Kernel)))
    ImageX, ImageY = X, X
    KernelX, KernelY = K, K
    ImageOut=np.array([0*j for j in range(X*X)])
    if(len(Image)==0 or len(Kernel)==0):
        return 0
    kCenterX=int(KernelX/2)
    kCenterY=int(KernelY/2)
    #print(kCenterX,kCenterY)
    #从(i,ImageY-i)和(i,ImageX-i)变换开始计算控制卷积和3*3矩阵相乘的位置
    for i in range(0,ImageY):
        for j in range(0,ImageX):
            sum=0
            for m in range(0,KernelY):
                mm=KernelY-1-m
                for n in range(0,KernelX):
                    nn=KernelX-1-n
                    rowIndex=i+m-kCenterY
                    colIndex=j+n-kCenterX
                    if(rowIndex>=0 and rowIndex<ImageY and colIndex>=0 and colIndex<ImageX):
                        sum+=Image[ImageX*rowIndex+colIndex]*Kernel[KernelX*mm+nn]
                    n+=1
                m+=1
            ImageOut[ImageX*i+j]=sum
            j+=1
        i+=1
    end=time()
    print(str(end-start))
    return ImageOut

start1 = time()
Imageout=convolve2D(result1,Kernel1)
stop1 = time()
print("一维卷积",str(stop1-start1)+"秒")
#print(Imageout)

n=int(np.sqrt(len(Imageout)))
#print(n)
#将一维数组切分成二维数组
trans = [Imageout[n*i:n*(i+1)] for i in range(n)]
#print(trans)

#测试
#Image=[1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,1,1,0,0,1,1,0,0]
#Kernel=[1,0,1,0,1,0,1,0,1]
# Image=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25]
# Kernel=[1,2,3,4]#计算结果实际卷积核是[[4,3],[2,1]]，在计算的时候进行了转换
# Image=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25]
# Kernel=[1,2,3,4,5,6,7,8,9]#计算结果实际卷积核是[[9,8,7],[6,5,4],[3,2,1]]，在计算的时候进行了转换
# start = time()
# Image=[2*i for i in range(0,160000)]
# Kernel=[1,2,3,4,5,6,7,8,9]
# Imageout=convolve2D(Image,Kernel)
# stop = time()
# print(Imageout)
# print("Time",str(stop-start)+"秒")