写一段python代码实现以下内容：1 生成有损图像a 受损图像X是由原始图像添加了不同噪声遮罩noisemasksM ∈ ℛ�∗�∗�得到的X = I ⊙ M其中⊙是逐元素相乘。b 噪声遮罩仅包含01值。对原图的噪声遮罩的可以 RGB 通道分别以080406 的噪声概率产生的即噪声遮罩 RGB 通道的像素值各有804060的概率值为 0否则为 12 有损图像的恢复使用区域二元线性回归模型进行图像

import numpy as np
from PIL import Image

# 生成有损图像
def generate_noisy_image(image_path):
    # 读取原始图像
    img = Image.open(image_path)
    # 转换为numpy数组
    img_arr = np.asarray(img)
    # 获取图像尺寸
    height, width, channel = img_arr.shape
    # 生成噪声遮罩
    noise_mask = np.zeros((height, width, channel), dtype=np.uint8)
    noise_mask[:, :, 0] = np.random.choice([0, 1], size=(height, width), p=[0.8, 0.2])
    noise_mask[:, :, 1] = np.random.choice([0, 1], size=(height, width), p=[0.4, 0.6])
    noise_mask[:, :, 2] = np.random.choice([0, 1], size=(height, width), p=[0.6, 0.4])
    # 生成有损图像
    noisy_img_arr = img_arr * noise_mask
    # 转换为PIL图像
    noisy_img = Image.fromarray(noisy_img_arr)
    return noisy_img

# 有损图像的恢复
def restore_image(noisy_image_path):
    # 读取有损图像
    noisy_img = Image.open(noisy_image_path)
    # 转换为numpy数组
    noisy_img_arr = np.asarray(noisy_img)
    # 获取图像尺寸
    height, width, channel = noisy_img_arr.shape
    # 初始化恢复图像数组
    restored_img_arr = np.zeros((height, width, channel), dtype=np.uint8)
    # 对于每个像素
    for i in range(height):
        for j in range(width):
            for k in range(channel):
                # 如果噪声遮罩为1，则直接使用有损图像像素值
                if noisy_img_arr[i, j, k] != 0:
                    restored_img_arr[i, j, k] = noisy_img_arr[i, j, k]
                else:
                    # 否则计算区域二元线性回归模型
                    x = i - 1
                    y = j - 1
                    while x >= 0 and noisy_img_arr[x, j, k] == 0:
                        x -= 1
                    while y >= 0 and noisy_img_arr[i, y, k] == 0:
                        y -= 1
                    if x < 0 or y < 0:
                        restored_img_arr[i, j, k] = 0
                    else:
                        x1 = x
                        y1 = y
                        x2 = i - 1
                        y2 = j - 1
                        while x2 >= 0 and noisy_img_arr[x2, j, k] == 0:
                            x2 -= 1
                        while y2 >= 0 and noisy_img_arr[i, y2, k] == 0:
                            y2 -= 1
                        if x2 < 0 or y2 < 0:
                            restored_img_arr[i, j, k] = 0
                        else:
                            x3 = x2
                            y3 = y1
                            x4 = x1
                            y4 = y2
                            A = np.array([[x1, y1, 1], [x2, y2, 1], [x3, y3, 1]])
                            b = np.array([noisy_img_arr[x1, y1, k], noisy_img_arr[x2, y2, k], noisy_img_arr[x3, y3, k]])
                            x0 = np.linalg.solve(A, b)
                            restored_img_arr[i, j, k] = int(round(x0[0]*i + x0[1]*j + x0[2]))
    # 转换为PIL图像
    restored_img = Image.fromarray(restored_img_arr)
    return restored_img

# 计算误差
def calculate_error(original_image_path, restored_image_path):
    # 读取原始图像和恢复图像
    original_img = Image.open(original_image_path)
    restored_img = Image.open(restored_image_path)
    # 转换为numpy数组
    original_img_arr = np.asarray(original_img)
    restored_img_arr = np.asarray(restored_img)
    # 计算2-范数之和
    error = np.linalg.norm(original_img_arr - restored_img_arr)
    return error

# 测试
if __name__ == "__main__":
    # 生成有损图像
    noisy_img = generate_noisy_image("original_image.jpg")
    noisy_img.save("noisy_image.jpg")
    # 恢复图像
    restored_img = restore_image("noisy_image.jpg")
    restored_img.save("restored_image.jpg")
    # 计算误差
    error = calculate_error("original_image.jpg", "restored_image.jpg")
    print("Error:", error)