数字图像处理

简述

1. 先安装个pycharm（或者其他类似的）。
2. 点击文件—》设置—》项目—》python解释器

3. 点击pip，搜索“numpy”，选中搜索结果，点击左下的“安装内容”
   
4. 复制粘贴之后把所有的打印语句打开即可

代码

import numpy as np

a = np.array([[1, 3, 9, 6, 8], [4, 1, 2, 7, 4], [3, 6, 0, 6, 4], [6, 6, 3, 1, 5]])


# shape获得矩阵的行列数，以列表形式返回
# print(a.shape)
def count(array):
    # 统计各个数字出现的次数
    # 创建一个列表存放，列表索引为0存放数字0出现的次数，依次类推
    count_num = []
    for k in range(10):
        # 把计数清零
        num = 0
        for i in range(array.shape[0]):
            for j in range(array.shape[1]):
                if a[i, j] == k:
                    num = num + 1
                    # 判断完最后一个数字再记录，一定要判断完该数字
                if i == 3 and j == 4:
                    count_num.append(num)
    return count_num


# print(count(a))


# 根据灰度分布个数计算分布概率，结果保留两位小数
def distribution_probability(array):
    count_rate = []
    count_num = count(array)
    for num in count_num:
        # 结果保留两位小数
        count_rate.append(format(float(num / array.size), '.2f'))
    return count_rate


# print(distribution_probability(a))


def cumulative_probability(array):
    # 计算累计分布概率,小数点后保留两位
    cumulative_rate = []
    count_rate = distribution_probability(array)
    s = 0
    for rate in count_rate:
        s = s + float(rate)
        cumulative_rate.append(format(float(s), '.2f'))
    return cumulative_rate


# print(cumulative_probability(a))


def insinuation(array, limit):
    # 计算灰度值的映射关系
    # 初始化一个列表，起始值为 limit[0] ，终止值为 limit[1]-1
    insinuation_list = list(range(limit[0], limit[1]))
    cumulative_rate = cumulative_probability(array)
    for i in range(len(cumulative_rate)):
        z = round(float(insinuation_list[i]) * float(cumulative_rate[i]))
        if z < limit[0]:
            z = limit[0]
        insinuation_list[i] = z
    return insinuation_list


# print(insinuation(a, [0, 10]))

b = np.array([[1, 0, 9, 16, 18], [4, 5, 8, 17, 14], [3, 6, 10, 11, 16], [2, 7, 13, 12, 15]])


# 计算新图像大小，k1、k2为缩小倍数
def new_image_size(array, k1, k2):
    m = array.shape[0]
    n = array.shape[1]
    m1 = round(m * k1)
    n1 = round(n * k2)
    size = [m1, n1]
    return size


# print(new_image_size(b, 0.5, 0.6))


# 计算新图像每一行对应原图像哪一行，每一列对应原图像每一列
def image_corresponding_position(array, k1, k2):
    size = new_image_size(array, k1, k2)
    row = []
    for i in range(1, size[0] + 1):
        r = round(i / k1)
        row.append(r)
    col = []
    for j in range(1, size[1] + 1):
        c = round(j / k2)
        col.append(c)
    return row, col


# print(image_corresponding_position(b, 0.5, 0.6))
#
# print('幅值')
#
# print('位置')

C = np.array([[3, 2, 5], [6, 6, 4], [4, 7, 8]])
# 均值滤波