jupyter图像二值化

要在Jupyter中进行图像二值化，你可以使用Python的Pillow库。以下是一个简单的示例代码，演示如何将图像转换为二值图像：

from PIL import Image

# 打开图像文件
image = Image.open("image.jpg")

# 转换为灰度图像
gray_image = image.convert('L')

# 进行二值化处理
threshold = 128  # 阈值，根据需求自行调整
binary_image = gray_image.point(lambda x: 0 if x < threshold else 255, '1')

# 显示二值图像
binary_image.show()

请确保已安装Pillow库（可以通过`pip install Pillow`安装），并将"image.jpg"替换为你要处理的图像文件路径。代码中的阈值设置为128，即灰度值小于128的像素被转换为黑色，大于等于128的像素被转换为白色。

运行代码后，将显示处理后的二值图像。你还可以将二值图像保存为文件，使用`binary_image.save("output.jpg")`即可。

相关问题

jupyter notebook实现答题卡识别

以下是使用Jupyter Notebook实现答题卡识别的步骤：

1.安装必要的库，包括OpenCV、numpy、matplotlib和Pillow。可以使用以下命令进行安装：

!pip install opencv-python numpy matplotlib Pillow

2.导入所需的库：

import cv2
import numpy as np
from matplotlib import pyplot as plt
from PIL import Image

3.读取答题卡图片并进行灰度化和二值化处理：

img = cv2.imread('answer_sheet.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)

4.对二值化后的图片进行膨胀操作，以便更好地检测轮廓：

kernel = np.ones((3, 3), np.uint8)
dilation = cv2.dilate(thresh, kernel, iterations=1)

5.查找轮廓并绘制轮廓：

contours, hierarchy = cv2.findContours(dilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
img_contours = img.copy()
cv2.drawContours(img_contours, contours, -1, (0, 255, 0), 3)

6.根据轮廓的位置和大小，提取出每个答案的区域：

rects = [cv2.boundingRect(cnt) for cnt in contours]
roi_list = []
for rect in rects:
    x, y, w, h = rect
    if w > 20 and h > 20:
        roi = img[y:y+h, x:x+w]
        roi_list.append(roi)

7.对每个答案区域进行处理，提取出选项：

def get_option(roi):
    gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
    ret, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
    kernel = np.ones((3, 3), np.uint8)
    dilation = cv2.dilate(thresh, kernel, iterations=1)
    contours, hierarchy = cv2.findContours(dilation, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    rects = [cv2.boundingRect(cnt) for cnt in contours]
    option_list = []
    for rect in rects:
        x, y, w, h = rect
        if w > 10 and h > 10:
            option = roi[y:y+h, x:x+w]
            option_list.append(option)
    return option_list

options_list = []
for roi in roi_list:
    options = get_option(roi)
    options_list.append(options)

8.将每个选项区域转换为灰度图像，并计算非零像素的数量，以确定选项是否被选中：

def is_selected(option):
    gray = cv2.cvtColor(option, cv2.COLOR_BGR2GRAY)
    ret, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
    non_zero_count = cv2.countNonZero(thresh)
    if non_zero_count > 100:
        return True
    else:
        return False

result = []
for options in options_list:
    selected = []
    for option in options:
        if is_selected(option):
            selected.append(True)
        else:
            selected.append(False)
    result.append(selected)

9.输出结果：

print(result)

写一个在jupyterLab上对一张灰度图像进行基于游程编码的图像压缩代码，并能修改压缩率

好的，以下是基于游程编码的图像压缩代码，使用Python语言，可以在JupyterLab上运行：

import numpy as np

def runlength_encode(image):
    # 将图像转换为一维数组
    image_1d = image.reshape(-1)
    
    # 初始化游程编码的列表
    encoding = []
    
    # 记录当前像素值和游程长度的变量
    current_pixel = image_1d[0]
    run_length = 1
    
    # 从第二个像素开始遍历数组
    for pixel in image_1d[1:]:
        # 如果当前像素和前一个像素相同，则游程长度加一
        if pixel == current_pixel:
            run_length += 1
        # 如果当前像素和前一个像素不同，则将前一个像素和游程长度记录下来，并更新变量
        else:
            encoding.append((current_pixel, run_length))
            current_pixel = pixel
            run_length = 1
    
    # 将最后一个像素和游程长度记录下来
    encoding.append((current_pixel, run_length))
    
    return encoding

def runlength_decode(encoding, image_shape):
    # 创建一个空的图像数组
    image_1d = np.zeros(np.prod(image_shape), dtype=np.uint8)
    
    # 从第一个像素开始遍历编码列表
    index = 0
    for pixel, run_length in encoding:
        # 将当前像素的游程解码为多个像素，并将它们写入图像数组中
        for i in range(run_length):
            image_1d[index] = pixel
            index += 1
    
    # 将一维数组转换为二维图像
    image = image_1d.reshape(image_shape)
    
    return image

# 测试代码
# 加载一张灰度图像
image = np.array([[100, 100, 100, 100, 100],
                  [100, 50, 50, 50, 100],
                  [100, 50, 0, 50, 100],
                  [100, 50, 50, 50, 100],
                  [100, 100, 100, 100, 100]], dtype=np.uint8)

# 对图像进行游程编码
encoding = runlength_encode(image)

# 输出编码结果
print("编码结果：")
print(encoding)

# 修改压缩率
compression_ratio = 0.5

# 计算需要保留的编码数量
num_codes_to_keep = int(len(encoding) * compression_ratio)

# 保留前面的编码
truncated_encoding = encoding[:num_codes_to_keep]

# 将编码解码为图像
decoded_image = runlength_decode(truncated_encoding, image.shape)

# 输出解码结果
print("解码结果：")
print(decoded_image)

这段代码中，`runlength_encode`函数将一张灰度图像进行游程编码，返回一个包含每个像素值和它连续出现的次数的元组列表。`runlength_decode`函数将一个游程编码的列表解码为一张灰度图像。在测试代码中，我们先对一张灰度图像进行游程编码，然后根据需要保留的编码数量来修改压缩率，最后将编码解码为图像。