python+opencv图像处理

pip install opencv-python 安装opencv的包（open source computer vision libraries实现了图像处理和计算机视觉方面的很多通用算法。）
pip install opencv-contrib-python （这是opencv的功能扩展包）
pip install pytesseract （py超立方体—>视觉识别工具，它将识别和“读取”嵌入在图像中的文本–如数字验证码）
numpy包 ---->封装了一些线性代数，随机数，数列变换，能处理N维的数组
pip3 install matplotlib图像直方图处理–>直译是matlab绘图库 (只需几行代码，就可以生成绘图、直方图、功率谱、条形图、误差图、散点图等。)
scipy 使用参考https://www.jianshu.com/p/6c742912047f（数学运算的）
PCV ----> Python library for computer vision 纯python的计算机视觉库（比较老的包了），安装过程如下：

https://github.com/Li-Shu14/PCV
将下载的文件解压
打开cmd，执行如下指令：
（1）执行cd命令，转到你所解压到的PCV的文件夹中。
（2）输入python setup.py install
在安装第三方模块时，会出现安装超时，安装不成功，这时更换下载源就行：
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple matplotlib

图像的输入和读取

import cv2 as cv
import numpy as np  #可计算均值，中和，对数

def clamp(pv):
    if pv>255:
        return 255
    if pv<0:
        return 0
    else:
        return pv

# 均值模糊

def avg_blur_demo(image):
    dst=cv.blur(image,(5,5))  # 使用opencv自带的均值模糊库函数，可以用来去噪
    cv.imshow("avg_blur_demo",dst)  # 模糊能去噪的原理是使用了卷积原理

# 中值模糊它对椒盐（黑白斑点）噪声有很好的去噪效果


def median_blur_demo(image):
    dst=cv.medianBlur(image,5)
    cv.imshow("median_blur_demo",dst)

# 自定义模糊

def custom_blur_demo(image):
    kernel=np.ones([5,5],np.float32)/25  # 定义5*5，/25防止溢出
    dst=cv.filter2D(image,-1,kernel=kernel)   #filter2D对图像做卷积
    cv.imshow("custom_blur_demo",dst)

# 高斯模糊
def gaussian_noise(image):
    h,w,c=image.shape
    for row in range(h):
        for col in range(w):
            s=np.random.normal(0,20,3) # 产生0到20的三个随机数
            b=image[row,col,0] # blue
            g=image[row,col,1] # green
            r=image[row,col,2] # red

            image[row,col,0]=clamp(b+s[0])  # 防止溢出
            image[row,col,1]=clamp(g+s[1])  # 防止溢出,如果都写成b，b，b就变成灰度图像了
            image[row,col,2]=clamp(r+s[2])  # 防止溢出
    cv.imshow("gaussian_noise",image)
    
src=cv.imread("D:\\demo.jpg")
#src=cv.imread("D:\\jiaoyan1.jpg")
cv.namedWindow("input image",cv.WINDOW_AUTOSIZE)
cv.imshow("input image",src)
#dst=cv.GaussianBlur(src,(0,0),15) #cv库自带的高斯模糊，src = source 源 dst = destination 目的
dst=cv.GaussianBlur(src,(5,5),0)  # 低高斯模糊可以对高高斯模糊去噪。
#avg_blur_demo(src)
#median_blur_demo(src)
#custom_blur_demo(src)
# gaussian_noise(src)
cv.imshow("cv's guassBlur",dst)  #可以保留图像的基本轮廓信息，比均值模糊好。原理是让像素的权重一样
cv.waitKey(0) # 等待下一个输出
cv.destroyAllWindows()  # 关闭所有窗口

hsv+inRange()可作为图像追综使用

图像中噪声的来源有许多种，这些噪声来源于图像采集、传输、压缩等各个方面。噪声的种类也各不相同，比如椒盐噪声，高斯噪声等，针对不同的噪声有不同的处理算法。

噪声是直接叠加在原始图像上的，这个噪声可以是椒盐噪声、高斯噪声。理论上来说，如果能够精确地获得噪声，用输入图像减去噪声就可以恢复出原始图像。但现实往往很骨感，除非明确地知道噪声生成的方式，否则噪声很难单独求出来。

工程上，图像中的噪声常常用高斯噪声来近似表示，其中，是噪声的方差，越大，噪声越大。一个有效的去除高斯噪声的方式是图像求平均，对N幅相同的图像求平均的结果将使得高斯噪声的方差降低到原来的N分之一，现在效果比较好的去噪算法都是基于这一思想来进行算法设计。

https://blog.csdn.net/qauchangqingwei/article/details/83339593

import cv2 as cv
import numpy as np  #可计算均值，中和，对数

# 均值模糊

def avg_blur_demo(image):
    dst=cv.blur(image,(5,5))  # 使用opencv自带的均值模糊库函数，可以用来去噪
    cv.imshow("avg_blur_demo",dst)  # 模糊能去噪的原理是使用了卷积原理

# 中值模糊它对椒盐（黑白斑点）噪声有很好的去噪效果


def median_blur_demo(image):
    dst=cv.medianBlur(image,5)
    cv.imshow("median_blur_demo",dst)

# 自定义模糊

def custom_blur_demo(image):
    kernel=np.ones([5,5],np.float32)/25  # 定义5*5，/25防止溢出
    dst=cv.filter2D(image,-1,kernel=kernel)   #filter2D对图像做卷积
    cv.imshow("custom_blur_demo",dst)
    
# src=cv.imread("D:\\demo.jpg")
src=cv.imread("D:\\jiaoyan1.jpg")
cv.namedWindow("input image",cv.WINDOW_AUTOSIZE)
cv.imshow("input image",src)
avg_blur_demo(src)
median_blur_demo(src)
custom_blur_demo(src)
cv.waitKey(0) # 等待下一个输出
cv.destroyAllWindows()  # 关闭所有窗口

import cv2 as cv
import numpy as np
from matplotlib import pyplot as plt


def plot_demo(image):
    plt.hist(image.ravel(),256,[0,256]) #ravel是0~255， 统计频次，range，desity
    plt.show("直方图")

def imge_hist(image):
    color=('blue','green','red')
    for i,color in enumerate(color):
        hist=cv.calcHist([image],[i],None,[256],[0,256])
        plt.plot(hist,color=color)
        plt.xlim([0,256])
    plt.show()

# 直方图均衡化

def equalHist_demo(image):
    gray=cv.cvtColor(image,cv.COLOR_BGR2GRAY)
    dst=cv.equalizeHist(gray)
    cv.imshow("equalHist_demo",dst)

# 
def clache_demo(image):
    gray=cv.cvtColor(image,cv.COLOR_BGR2GRAY)
    clache=cv.createCLAHE(cliplimit=5.0,tileGridSize=(8,8))  # 默认40太大，改成5.0
    dst=clache.apply(gray)
    cv.imshow("clache_demo",dst)

    
src=cv.imread("D:\\demo.jpg")
cv.namedWindow("input image",cv.WINDOW_AUTOSIZE)
cv.imshow("input image",src)
plot_demo(src)
cv.waitKey(0)
cv.destroyAllWindows()


# 直方图均衡化，直方图比较（增强色彩的对比度---局部直方图均衡化）

# 直方图均衡化都是基于灰度直方图的，所以需要

python数字图像处理-图像噪声与去噪算法

https://blog.csdn.net/u012123989/article/details/78821037

模板

import cv2 as cv
import numpy as np

src=cv.imread("D:\\softManager\\install\\Python\\Python36\\my_workspace\\img_src\\src.jpg")
cv.namedWindow("input image",cv.WINDOW_AUTOSIZE)
cv.imshow("input image",src)

cv.waitKey(0) # 等待下一个输出
cv.destroyAllWindows()  # 关闭所有窗口

中值滤波（有点小瑕疵的）

import cv2 as cv
import numpy as np

def Median_filtering(image,window_size):   #image为传入灰度图像，window_size为滤波窗口大小
    high, wide = image.shape
    img = image.copy()
    mid = (window_size-1) // 2
    med_arry = []
    for i in range(high-window_size):
        for j in range(wide-window_size):
            for m1 in range(window_size):
                for m2 in range(window_size):
                    med_arry.append(int(image[i+m1,j+m2]))

            # for n in range(len(med_arry)-1,-1,-1):
            med_arry.sort()   				#对窗口像素点排序
            # print(med_arry)
            img[i+mid,j+mid] = med_arry[(len(med_arry)+1) // 2]        #将滤波窗口的中值赋给滤波窗口中间的像素点,这里出现了下标溢出的问题
            del med_arry[:]
    print("结束")
    cv.imshow("Median_filtering",img)



src=cv.imread("D:\softManager\install\Python\Python36\my_workspace\ep1\median_blur\lenna_jiaoyan.jpg")
cv.namedWindow("input image",cv.WINDOW_AUTOSIZE)
cv.imshow("input image",src)
# 将素材图片转为灰度图像
gray=cv.cvtColor(src,cv.COLOR_BGR2GRAY)
#Median_filtering(gray,cv.WINDOW_AUTOSIZE)
Median_filtering(gray,5*5)
cv.waitKey(0) # 等待下一个输出
cv.destroyAllWindows()  # 关闭所有窗口

完整运行成功的中值滤波去噪算法

非常感谢原博主
https://blog.csdn.net/kingroc/article/details/96166953

# -*- coding: gb2312 -*-
import cv2
import numpy as np


def medianBlur(img, kernel, padding_way='ZERO', Multithreading=False):
    # 检测传入的kernel是否为一个合法数组.
    if kernel % 2 == 0 or kernel is 1:
        print('kernel size need 3, 5, 7, 9....')
        return None

    # 通过kernel的大小来计算paddingSize的大小
    paddingSize = kernel // 2

    # 获取图片的通道数
    layerSize = len(img.shape)

    # 获取传入的图片的大小
    height, width = img.shape[:2]

    # 假设输入,如下矩阵,5x5
    # [[2 6 3 4 7]
    #  [6 1 7 1 5]
    #  [4 6 7 3 3]
    #  [3 1 8 8 6]
    #  [2 4 8 0 7]]

    # 这里是对多通道的处理
    if layerSize == 3:  # 多通道的处理方式,就是反复的调用单通道.
        matMutbase = np.zeros_like(img)
        for l in range(matMutbase.shape[2]):
            matMutbase[:, :, l] = medianBlur(img[:, :, l], kernel, padding_way)
        return matMutbase
    elif layerSize == 2:  # 单通道是中值滤波的实际工作的位置.
        # 实现方式和np.lib.pad相同
        # matBase = np.lib.pad(img,paddingSize, mode='constant', constant_values=0)
        matBase = np.zeros((height + paddingSize * 2, width + paddingSize * 2), dtype=img.dtype)

        # 创建一个添加了padding的矩阵,初始值为0
        # 如果kernel的大小为3,所以从5x5变成了7x7
        # [[0 0 0 0 0 0 0]
        #  [0 0 0 0 0 0 0]
        #  [0 0 0 0 0 0 0]
        #  [0 0 0 0 0 0 0]
        #  [0 0 0 0 0 0 0]
        #  [0 0 0 0 0 0 0]
        #  [0 0 0 0 0 0 0]]

        matBase[paddingSize:-paddingSize, paddingSize:-paddingSize] = img
        # 将原值写入新创建的矩阵当中
        # [[0 0 0 0 0 0 0]
        # [0 2 6 3 4 7 0]
        # [0 6 1 7 1 5 0]
        # [0 4 6 7 3 3 0]
        # [0 3 1 8 8 6 0]
        # [0 2 4 8 0 7 0]
        # [0 0 0 0 0 0 0]]
        # print(matBase)
        if padding_way is 'ZERO':
            pass
        elif padding_way is 'REPLICA':
            for r in range(paddingSize):
                matBase[r, paddingSize:-paddingSize] = img[0, :]
                matBase[-(1 + r), paddingSize:-paddingSize] = img[-1, :]
                matBase[paddingSize:-paddingSize, r] = img[:, 0]
                matBase[paddingSize:-paddingSize, -(1 + r)] = img[:, -1]
                # 通过REPLICA后的矩阵,讲四个边补齐
                # [[0 2 6 3 4 7 0]
                # [2 2 6 3 4 7 7]
                # [6 6 1 7 1 5 5]
                # [4 4 6 7 3 3 3]
                # [3 3 1 8 8 6 6]
                # [2 2 4 8 0 7 7]
                # [0 2 4 8 0 7 0]]
                # 实现方式和np.lib.pad相同
                # matBase = (img, padding, mode='edge')
            # print(matBase)
        else:
            print('padding_way error need ZERO or REPLICA')
            return None

        # 创建用于输出的矩阵
        matOut = np.zeros((height, width), dtype=img.dtype)
        # 这里是遍历矩阵的每个点
        for x in range(height):
            for y in range(width):
                # 获取kernel X kernel 的内容,并转化成队并列
                line = matBase[x:x + kernel, y:y + kernel].flatten()
                # 队列排序处理.
                line = np.sort(line)
                # 取中间值赋值
                matOut[x, y] = line[(kernel * kernel) // 2]
        return matOut
    else:
        print('image layers error')
        return None


def main():
    # 读取原始图片
    img = cv2.imread("D:\softManager\install\Python\Python36\my_workspace\img_src\lenna1.jpg")
    # print(img)

    # 使用自己手写的medianBlur进行中值滤波啊
    myself = medianBlur(img, 5, padding_way='REPLICA')
    if myself is None:
        return

    # 调用OpenCV的接口进行中值滤波
   ## opencv = cv2.medianBlur(img, 3)

    # 这里进行图片合并
    img = np.hstack((img, myself))
    ##img = np.hstack((img, opencv))

    # 显示对比效果
    cv2.imshow('ORG + myself + OpenCV', img)

    cv2.waitKey()
    cv2.destroyAllWindows()


if __name__ == '__main__':
    main()

可运行的图像直方图均衡化

from matplotlib import pyplot as plt
import sys
import numpy as np
import cv2 as mpimg


def equalization(gray_value):
    """
    传入灰度值，对灰度值做均衡化，不需要返回，直接修改传入的参数
    :param gray_value:
    """
    # 统计灰度直方图
    gray = np.zeros(256)
    row, column = gray_value.shape
    for i in range(row):
        for j in range(column):
            gray[gray_value[i][j]] += 1

    # 计算灰度占比
    gray /= (row * column)
    # 显示灰度直方图
    plt.subplot(2, 2, 2)
    plt.plot(gray)

    cumsum = np.cumsum(gray)  # 计算累积和

    # 均衡化
    # equa_t[i]=j表示原灰度值i经过均衡化后转化为灰度值j
    # 255×累积和四舍五入为int型
    equa_t = np.array((255 * cumsum + 0.5)).astype(np.int32)
    # 统计均衡化后的灰度数量
    equa_gray = np.zeros(256)
    for i in range(256):
        equa_gray[equa_t[i]] += gray[i]
    # 显示均衡化后的直方图
    plt.subplot(2, 2, 4)
    plt.plot(equa_gray)
    # 对原灰度矩阵做均衡化
    for i in range(row):
        for j in range(column):
            gray_value[i][j] = equa_t[gray_value[i][j]]


def run(img_path):
    img_array = mpimg.imread(img_path)
    plt.subplot(2, 2, 1)
    plt.imshow(img_array)
    img_array *= 255
    img_array = img_array.astype(np.int32)
    equalization(img_array[:, :, 0])
    equalization(img_array[:, :, 1])
    equalization(img_array[:, :, 2])
    img_array = img_array.astype(np.float64)
    img_array /= 255
    plt.subplot(2, 2, 3)
    plt.imshow(img_array)


if __name__ == "__main__":
    if sys.argv.__len__() <= 1:
        png = input("请输入要处理的图片名:\n")
    else:
        png = sys.argv[1]
    run(png)
    plt.show()