from cv2 import Laplacian
import numpy as np
import cv2
import math

### 计算处理
# 逻辑与
def and_operation(path1,path2):
    X=cv2.imread(path1,0)
    Y=cv2.imread(path2,0)
    result=X&Y
    print(np.sum(result))
    return result

# 逻辑或
def or_operation(path1,path2):
    X=cv2.imread(path1,0)
    Y=cv2.imread(path2,0)
    result=X|Y
    print(np.sum(result))
    return result

# 逻辑非
def not_operation(path1):
    X=cv2.imread(path1,0)
    result=~X
    print(np.sum(result))
    return result

# 加法运算
def ope_add(path1,path2):
    X=cv2.imread(path1,0)
    Y=cv2.imread(path2,0)
    result = cv2.add(X,Y)
    print(np.sum(result))
    return result


# 减法运算
def ope_subtract(path1,path2):
    X=cv2.imread(path1,0)
    Y=cv2.imread(path2,0)
    result = cv2.subtract(X,Y)
    print(np.sum(result))
    return result

# 乘法运算
def ope_multiply(path1,path2):
    X=cv2.imread(path1,0)
    Y=cv2.imread(path2,0)
    result = cv2.multiply(X,Y)
    print(np.sum(result))
    return result
# 除法运算
def ope_divide(path1,path2):
    X=cv2.imread(path1,0)
    Y=cv2.imread(path2,0)
    result = cv2.divide(X,Y)
    print(np.sum(result))
    return result


### 几何变换
# 翻转
def Flip(path1):
    src=cv2.imread(path1,1)
    #水平镜像
    horizontal=cv2.flip(src,1)
    #垂直镜像
    vertical=cv2.flip(src,0)
    #对角镜像 ，并保存
    cross=cv2.flip(src,-1)
    return cross

# 仿射变换
def affine_trans(path1):
    # 获取图像shape
    src=cv2.imread(path1,1)
    rows, cols = src.shape[: 2]
    post1=np.float32([[50,50],[200,50],[50,200]])
    post2=np.float32([[10,100],[200,50],[100,250]])
    M=cv2.getAffineTransform(post1,post2)
    result = cv2.warpAffine(src,M,(rows,cols))
    return result


### 形态学
# 腐蚀
def erosion(path):
    src = cv2.imread(path, cv2.IMREAD_UNCHANGED)
    kernel=cv2.getStructuringElement(cv2.MORPH_CROSS,(5,5))
    erosion=cv2.erode(src,kernel)
    return erosion

# 膨胀
def dilation(path):
    src = cv2.imread(path, cv2.IMREAD_UNCHANGED)
    kernel=cv2.getStructuringElement(cv2.MORPH_CROSS,(5,5))
    dilation=cv2.dilate(src,kernel)
    return dilation

# 开运算
def morph_open(path):
    src = cv2.imread(path, cv2.IMREAD_UNCHANGED)
    kernel=cv2.getStructuringElement(cv2.MORPH_CROSS,(5,5))
    open = cv2.morphologyEx(src, cv2.MORPH_OPEN, kernel) 
    return open

# 闭运算
def morph_close(path):
    src = cv2.imread(path, cv2.IMREAD_UNCHANGED)
    kernel=cv2.getStructuringElement(cv2.MORPH_CROSS,(10,10),(-1,-1))
    dilation=cv2.dilate(src,kernel)
    close=cv2.erode(dilation,kernel)
    return close


### 图像增强
## 空域平滑
# 邻域平均法
def neighbor_aver(path):
    img=cv2.imread(path,1)
    result=cv2.blur(img,(5,5))
    return result

#中值滤波法
def median_filter(path):
    img=cv2.imread(path,1)
    result=cv2.medianBlur(img,5)
    return result

## 空域锐化
# Roberts梯度算子
def roberts(path):
    img=cv2.imread(path,0)
    height,width=img.shape[:2]
    result = np.zeros((height,width))
    for i in range(1,height-1):
        for j in range (1,width-1):
            result[i][j]=np.abs(img[i][j]-img[i+1][j+1])+np.abs(img[i+1][j]-img[i][j+1])
    return result

## 频域平滑
# 理想低通滤波器
def lowpass_filter(path):
    img=cv2.imread(path,0)
    src=np.fft.fft2(img)
    src_shift=np.fft.fftshift(src)
    #src_trans=20*np.log(np.abs(src_c))
    height,width=img.shape[:2]
    u=np.floor(height/2)
    v=np.floor(width/2)
    img_trans=np.zeros((height,width))
    d0=90
    for i in range(height):
        for j in range(width):
            d = np.sqrt((i-u)**2 + (j-v)**2)
            if d<=d0:
                img_trans[i][j]=1
    #iimg_trans=src_c*img_trans
    iimg_trans=np.multiply(src_shift,img_trans)
    iimg_shift=np.fft.ifftshift(iimg_trans)
    iimg=np.fft.ifft2(iimg_shift)
    img_back=np.abs(iimg)
    #img_back=np.real(iimg)
    img_back=(img_back-np.amin(img_back))/(np.amax(img_back)-np.amin(img_back))
    return img_back

#巴特沃斯低通滤波器
def butterworth_low_filter(path):
    img=cv2.imread(path,0)
    src=np.fft.fft2(img)
    src_shift=np.fft.fftshift(src)
    #src_trans=20*np.log(np.abs(src_c))
    height,width=img.shape[:2]
    u=np.floor(height/2)
    v=np.floor(width/2)
    img_trans=np.zeros((height,width))
    d0=90
    rank=2
    for i in range(height):
        for j in range(width):
            d = np.sqrt((i-u)**2 + (j-v)**2)
            img_trans[i][j]=1/(1+0.414*(d/d0)**(2*rank))
    #iimg_trans=src_c*img_trans
    iimg_trans=np.multiply(src_shift,img_trans)
    iimg_shift=np.fft.ifftshift(iimg_trans)
    iimg=np.fft.ifft2(iimg_shift)
    img_back=np.abs(iimg)
    #img_back=np.real(iimg)
    img_back=(img_back-np.amin(img_back))/(np.amax(img_back)-np.amin(img_back))
    return img_back


## 频域锐化
# 理想高通滤波器
def highpass_filter(path):
    img=cv2.imread(path,0)
    src=np.fft.fft2(img)
    src_shift=np.fft.fftshift(src)
    #src_trans=20*np.log(np.abs(src_c))
    height,width=img.shape[:2]
    u=np.floor(height/2)
    v=np.floor(width/2)
    img_trans=np.zeros((height,width))
    d0=90
    for i in range(height):
        for j in range(width):
            d = np.sqrt((i-u)**2 + (j-v)**2)
            if d>d0:
                img_trans[i][j]=1
    #iimg_trans=src_c*img_trans
    iimg_trans=np.multiply(src_shift,img_trans)
    iimg_shift=np.fft.ifftshift(iimg_trans)
    iimg=np.fft.ifft2(iimg_shift)
    img_back=np.abs(iimg)
    #img_back=np.real(iimg)
    img_back=(img_back-np.amin(img_back))/(np.amax(img_back)-np.amin(img_back))
    return img_back

#巴特沃斯高通滤波器
def butterworth_high_filter(path):
    img=cv2.imread(path,0)
    src=np.fft.fft2(img)
    src_shift=np.fft.fftshift(src)
    #src_trans=20*np.log(np.abs(src_c))
    height,width=img.shape[:2]
    u=np.floor(height/2)
    v=np.floor(width/2)
    img_trans=np.zeros((height,width))
    d0=90
    rank=2
    for i in range(height):
        for j in range(width):
            d = np.sqrt((i-u)**2 + (j-v)**2)
            img_trans[i][j]=1/(1+0.414*(d0/d)**(2*rank))
    #iimg_trans=src_c*img_trans
    iimg_trans=np.multiply(src_shift,img_trans)
    iimg_shift=np.fft.ifftshift(iimg_trans)
    iimg=np.fft.ifft2(iimg_shift)
    img_back=np.abs(iimg)
    #img_back=np.real(iimg)
    img_back=(img_back-np.amin(img_back))/(np.amax(img_back)-np.amin(img_back))
    return img_back


### 边缘检测
# Roberts算子
def robs(path):
    img = cv2.imread(path,0)
    # 2. Roberts算子
    kernelx=np.array([[-1,0],[0,1]],dtype=int)
    kernely=np.array([[0,-1],[1,0]],dtype=int)
    # 3. 卷积操作
    x=cv2.filter2D(img,cv2.CV_16S,kernelx)
    y=cv2.filter2D(img,cv2.CV_16S,kernely)
    # 4. 数据格式转换
    absX=cv2.convertScaleAbs(x)
    absY=cv2.convertScaleAbs(y)
    Roberts=cv2.addWeighted(absX,0.5,absY,0.5,0)
    return Roberts

#Sobel算子
def sob(path):
    img = cv2.imread(path,0)
    # 2. Roberts算子
    kernelx=cv2.Sobel(img,cv2.CV_16S,1,0)
    kernely=cv2.Sobel(img,cv2.CV_16S,0,1)
    # 3. 卷积操作
    x=cv2.filter2D(img,cv2.CV_16S,kernelx)
    y=cv2.filter2D(img,cv2.CV_16S,kernely)
    # 4. 数据格式转换
    absX=cv2.convertScaleAbs(x)
    absY=cv2.convertScaleAbs(y)
    Sobel=cv2.addWeighted(absX,0.5,absY,0.5,0)
    return Sobel

#Laplacian算子
def lap(path):
    # 1.读取图像
    img = cv2.imread(path,0)
    # 2. 高斯滤波
    img=cv2.GaussianBlur(img,(5,5),0,0)
    # 3. 拉普拉斯算法
    dst=cv2.Laplacian(img,cv2.CV_16S,ksize=3)
    # 4. 数据格式转换
    Laplacian=cv2.convertScaleAbs(dst)
    return Laplacian

#LoG边缘算子
def log(path):
    # 1.读取图像
    img = cv2.imread(path,0)
    # 2. 边缘扩充处理图像并使用高斯滤波处理该图像
    image=cv2.copyMakeBorder(img,2,2,2,2,borderType=cv2.BORDER_REPLICATE)
    image=cv2.GaussianBlur(image,(3,3),0,0)
    # 3. 使用Numpy定义LoG算子
    m1=np.array([[0,0,-1,0,0],[0,-1,-2,-1,0],[-1,-2,16,-2,-1],[0,-1,-2,-1,0],[0,0,-1,0,0]])
    # 4. 卷积运算
    # 为了使卷积对每个像素都进行运算，原图像的边缘像素要对准模板的中心。
    # 由于图像边缘扩大了2像素，因此要从位置2到行(列)-2
    image1=np.zeros(image.shape)
    rows=image.shape[0]
    cols=image.shape[1]
    for i in range(2,rows-2):
        for j in range(2,cols-2):
            image1[i,j]=np.sum(m1*image[i-2:i+3,j-2:j+3])
    # 5. 数据格式转换
    image1=cv2.convertScaleAbs(image1)
    return image1

### 图像噪声
# 噪声描述器
def noise_desc(path):
    image = cv2.imread(path,0)
    output = np.zeros(image.shape, np.uint8)
    # 遍历图像，获取叠加噪声后的图像
    for i in range(image.shape[0]):
        for j in range(image.shape[1]):
            if image[i][j]<100:
                # 添加食盐噪声
                output[i][j]=255
            elif image[i][j]>200:
                # 添加胡椒噪声
                output[i][j]=0
            else:
                # 不添加噪声
                output[i][j]=image[i][j]
    print(np.sum(output))
    return output

# 均值类滤波器
def aver_filter(path):
    image = cv2.imread(path,0)
    output = np.zeros(image.shape, np.uint8)
    # 遍历图像，进行均值滤波
    for i in range(image.shape[0]):
        for j in range(image.shape[1]):
            # 计算均值,完成对图片src的几何均值滤波
            ji = 1.0
            for n in range(-1,2):
                # 防止越界  
                if 0 <= j + n < image.shape[1]:   
                    ji *= image[i][j + n]   
            output[i][j] = int(math.pow(ji,1/3))

            # 滤波器的大小为1*3

            ######### End #########
    # 展示均值滤波后的图片
    return output

#排序统计类滤波器
def sort_filter(path):
    image = cv2.imread(path,0)
    # 待输出的图片
    output = np.zeros(image.shape, np.uint8)
    for i in range(image.shape[0]):
        for j in range(image.shape[1]):
            # 最大值滤波器
            max=0
            for m in range(-1, 2):  
                for n in range(-1, 2):  
                    # 防止越界  
                    if 0 <= i + m < image.shape[0] and 0 <= j + n < image.shape[1]:   
                        if max<image[i+m][j+n]:
                            max=image[i+m][j+n]  
                            # 更新最大值
            output[i][j]=max
    return output

#选择性滤波器
def opt_filter(path):
    image = cv2.imread(path,0)
    output = np.zeros(image.shape, np.uint8)
    max=200
    for i in range(image.shape[0]):  
        for j in range(image.shape[1]):  
            if image[i][j] <= max:  
                output[i][j] = 0 
            else:  
                output[i][j] = image[i][j] 
    return output


### 图像进阶
# 线条变化检测
def line_change(path):
    img = cv2.imread(path)
    img = cv2.GaussianBlur(img, (3, 3), 0)  
    edges = cv2.Canny(img, 50, 150, apertureSize=3)
    # 使用HoughLines算法  
    # rho为1  
    # theta为np.pi/2  
    # threshold为 118  
    # 其他的默认  
    #########  Begin #########  
    lines = cv2.HoughLines(edges, 1, np.pi/2, 118)  
    #########  end  ##########
    result = img.copy()  
    for i_line in lines:  
        for line in i_line:  
            rho = line[0]  
            theta = line[1]  
            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, (0, 0, 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, (0, 0, 255), 1)
    minLineLength = 200  
    maxLineGap = 15
    # 使用HoughLinesP算法  
    # rho为1  
    # theta为np.pi/2  
    # threshold为 118  
    # 并设置上面提供的minLineLength和maxLineGap  
    # 其他的默认  
    #########  Begin #########  
    linesP = cv2.HoughLinesP(edges, 1, np.pi / 180, 80, minLineLength, maxLineGap)  
    #########  end  ##########
    result_P = img.copy()  
    for i_P in linesP:  
        for x1, y1, x2, y2 in i_P:  
            cv2.line(result_P, (x1, y1), (x2, y2), (0, 255, 0), 3)
    return result_P