# 创建新的虚拟环境
python -m virtualenv myenv

# 进入虚拟环境
source myenv/bin/activate

# 安装
pip install -r requirements.txt

# 打开图片
im = Image.open("./invoice-images/test2.png")

# 截取图片
code = im.crop((850, 15, 1180, 155))

# 保存
code.save("./out/cut.png")

# 读取图片
img = cv2.imread("./out/cut.png")

# 转换
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 保存
cv2.imwrite("./out/gray.jpg", gray)

# 阈值分割
ret, thresh = cv2.threshold(gray, 95, 255, 1)

cv2.imwrite("thresh.jpg", thresh)

contours, hier = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

# 遍历所有的轮廓
for i in range(0, len(contours)):
    # 取得轮廓的起始点 x,y  与该点分别向 横、纵 延伸的距离
    x, y, w, h = cv2.boundingRect(contours[i])
    print((x, y), (x + w, y + h))
    # 画出框框
    cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 255), 1)

# 保存
cv2.imwrite("./out/save.jpg", img)

for i in range(0, len(contours)):
    x, y, w, h = cv2.boundingRect(contours[i])
    # print((x, y), (x + w, y + h))
    # cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 255), 1)

	# 75 是个神秘的数字
    if h * w >= 75:
        # 截取图片，注意这里先传入 y 再传入 x
        newimage = thresh[y : y + h , x  : x + w ]
        # 保存
        cv2.imwrite("./result/" + str(i) + ".jpg", newimage)

# 导包 我们这里使用 Pillow 包 导入的时候名字为 PIL
from PIL import Image 
import numpy as np
import os

# 预设图片的地址
preset_path = "./number-preset-dataset"

# 用来储存转换之后的矩阵
store = {}

# 写一个方法，方便后面调用
def get_preset():
    for root, dirs, files in os.walk(preset_path):
        for f in files:
            # 得到完整的路径 即 './preset/0.jpg'
            file_full_path = os.path.join(root, f)
            
            # 用 Pillow 中的 Image.open 打开图像
            image = Image.open(file_full_path) 
            
            # 转化成 numpy 数组
            arr = np.array(image) 
            
            # 对文件名分割 如 0.jpg => ('0', 'jpg')
            file_ext = f.rsplit('.', maxsplit=1)
            # 得到文件名 文件名即是这个图片的真实数字
            file_name = file_ext[0]
            
            # 存到字典中
            store[file_name] = arr

# 计算灰度值的平均值
avg = arr.mean()
            
hash_val = ''
            
            
for x in range(arr.shape[0]):
	for y in range(arr.shape[1]):
		if arr[x,y] > avg:
            # 大于平均值 放1
			hash_val += '1'
		else:
            # 小于平均值 放0
			hash_val += '0'

for i in range(0, len(contours)):
    x, y, w, h = cv2.boundingRect(contours[i])
    # print((x, y), (x + w, y + h))
    # cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 255), 1)


    if h*w >= 75:
        # !!! 注意这里截取的是二值化后的图片
        newimage = thresh[y : y + h , x  : x + w ]
        new_image_array = np.array(newimage)
        
        # 初始字符串的相似度 这里用 负数值 -1，之后的比较最少也是 0 就会覆盖掉这个值
        init = -1
        # 存储最大可能的数字 
        index = -1
        
        # store 即 预设数据的字典
        for k, v in store.items():
            # 计算相似度
            # 传入当前待识别图片的矩阵  以及所需要比较的一个感知哈希的字符串
            rsp = leven(new_image_array, v)
            # 若当前的相似度大于上一个
            if rsp >= init:
                # 则最有可能的数字为该数字 即 字典的 key 值 
                index = k
                # 更新 相似度的值
                init = rsp
        
        print("result", index)
        # 保存图片  
        # 图片名称的格式为： i-index.jpg 其中 i 为循环的顺序数， index 为我们预测的最有可能的数字
        cv2.imwrite("./result/" + str(i) + "- "+  str(index) + ".jpg", img[y : y + h , x  : x + w ])

import numpy as np
import Levenshtein

def leven(raw_image, string:str):
    """由 Levenshtein 算法计算相似度

    Args:
        raw_image (numpy.array): 图片数据的矩阵
        string (str): 另外一张图片的感知哈希字符串

    Returns:
        float: 相似度
    """
    
    avg = raw_image.mean()
            
    hash_val = ''
    
    for x in range(raw_image.shape[0]):
        for y in range(raw_image.shape[1]):
            if raw_image[x,y] > avg:
                hash_val += '1'
            else:
                hash_val += '0'
    
    return Levenshtein.ratio(hash_val, string)

def read_idx3(filename):
    with open(filename, 'rb') as fo:
        buf = fo.read()
        
        index = 0
        header = np.frombuffer(buf, '>i', 4, index)
        
        index += header.size * header.itemsize
        data = np.frombuffer(buf, '>B', header[1] * header[2] * header[3], index).reshape(header[1], -1)
        
        return data
    
def read_idx1(filename):
    with open(filename, 'rb') as fo:
        buf = fo.read()
        
        index = 0
        header = np.frombuffer(buf, '>i', 2, index)
        
        index += header.size * header.itemsize
        data = np.frombuffer(buf, '>B', header[1], index)
        
        return data

# 调用该方法
train_labels = read_idx1("mnist/train-labels.idx1-ubyte")

train_images = read_idx3("mnist/train-images.idx3-ubyte")

print(train_labels.shape, train_images.shape)

# >> (60000,) (60000, 784)

import matplotlib.pyplot as plt

plt.subplot(121)

# 我们输出第一张图片 即矩阵的整个第一行  同时我们对这个一维的行变成 二维的矩阵 
# 这里 -1 是指 让 numpy 自己推断应该取多少
# 因为我们的数据值都是 0-255 的灰度值，我们显示的时候也要指定为 灰度显示样式
plt.imshow(train_images[0, :].reshape(28, -1), cmap='gray')
plt.title('train 0')

print(train_labels[0])

# 获取测试集
test_labels = read_idx1("mnist/t10k-labels.idx1-ubyte")
test_images = read_idx3("mnist/t10k-images.idx3-ubyte")

print(test_images.shape)
# >> (10000, 784)

from collections import defaultdict

# 这里的 defaultdict 用于 键不存在的时候返回一个空的 list
data = defaultdict(lambda : [])

def sHash(img):
    """感知哈希

    Args:
        img ([type]): 一维 784 的数组

    Returns:
        [str]: 感知哈希
    """
    # 感知 哈希
    hash_val = ''
    avg = img.mean()
    
    for x in range(len(img)):
        if img[x] > avg:
            hash_val += '1'
        else:
            hash_val += '0'
    return hash_val

# 使用测试集 作为预处理
for i in range(len(test_images)):
    # 取出一张图片 即一整行
    img = test_images[i, :]
    # 计算感知哈希并存到 对应数字的 list 中
    data[test_labels[i]].append(sHash(img))

# 使用训练集 train-images 中的第一张用来测试
to_test_image = train_images[0, :]

# 计算感知哈希
test_hash = sHash(to_test_image)

def recognize_number(to_test_image_sHash:str):
    
    # list 中 第 i 个位置的值即该图片为数字 i 的可能性
    # 这里放 10 个 0
    result = [ 0 for i in range(10)]
    
    
    for k,v in data.items():
    # k - 数字  v - 该数字的所有感知哈希值的 list
    # 遍历所有的哈希并计算值
        for hash_val in v:
            # 计算该感知哈希和待测图片的感知哈希字符串的相似度
            leven_val = Levenshtein.ratio(to_test_image_sHash, hash_val)
            # 令 result 中存储可能成为某个数字的最大可能性
            # 即取最大相似度值
            if leven_val > result[k]:
                result[k] = leven_val

    return result

# 调用
result = recognize_number(test_hash)

# 输出最大的可能性值
print(max(result))

# 输出最大可能值所在的位置 即 我们预测的最可能的数字
print(result.index(max(result)))

# 输出 预测值的 list
print(result)

from PIL import Image

# 读取图片
diy_image = Image.open('./mnist/MNIST-6.jpg')

# 降维成一维的数据
diy_arr = np.array(diy_image).flatten()

# 输出出来图片
plt.subplot(122)
plt.imshow(diy_arr.reshape(28, -1), cmap='gray')
plt.title('diy 0')

# 再次降维，因为输出图片的时候我们进行了一次修改。
diy_arr = diy_arr.flatten()

# 计算预测结果
r = recognize_number(sHash(diy_arr))

print(max(r))

print(r.index(max(r)))

print(r)

# 测试结果准确率

statis = {}

# 用于统计的词典 分数字 每个数字都统计正确数和总数
for i in range(0, 10):
    statis[i] = {}
    
    # 正确数
    statis[i]["correct"] = 0
    # 总数
    statis[i]["all"] = 0

# 取前100个图片
for i in range(100):
    # 计算图片的感知哈希
    shash_val = sHash(train_images[i, :])
    
    # 预测结果 list
    r = recognize_number(shash_val)
    
    # 真实的值 即图片的 标签值
    real_val = train_labels[i]
    
    # 判断检测结果与真实值是否一致
    if r.index(max(r)) == real_val:
        # 若正确则 正确数 +1
        statis[real_val]["correct"] += 1
    # 总数 +1
    statis[real_val]["all"] += 1