问如何从python中的二进制文件中重建图像？

EN

from pathlib import Path
from typing import List

import imageio.v3 as iio
import numpy as np

secret_bit = 0


def max_msg_len(data: np.ndarray) -> int:
    row_size, column_size, layers = data.shape
    return (row_size * column_size * layers) // 8


def text_to_bits(txt: str) -> List[bool]:
    data = txt.encode()
    bin_str = "".join([f"{x:08b}" for x in data])
    bits = [x == "1" for x in bin_str]
    return bits


def bits_to_text(bits: List[bool]) -> bytes:
    data = bytearray()
    for x in range(0, (len(bits) // 8 * 8), 8):
        char = int("".join(["1" if i else "0" for i in bits[x: x + 8]]), 2)
        data.append(char)
    return_str = "".join([x for x in data.decode() if x.isprintable()])
    return return_str


def read_file(filename: Path) -> np.ndarray:
    return iio.imread(filename)


def write_file(filename: Path, data: bytes) -> None:
    iio.imwrite(filename, data)


def extract_message(data: np.ndarray) -> List[bool]:
    flat_data = data.flatten()
    extracted_bits = []
    for pixel in range(len(flat_data)):
        value = flat_data[pixel]
        found_bit = get_bit(value, secret_bit)
        extracted_bits.append(found_bit)
    return extracted_bits


def embed_message(data: np.ndarray, bits: List[bool]) -> bytes:
    orig_shape = data.shape
    flat_data = data.flatten()
    idx = 0
    bit_len = len(bits)
    for pixel in range(len(flat_data)):
        value = flat_data[pixel]
        if pixel < bit_len:
            flat_data[pixel] = set_bit(value, secret_bit, bits[pixel])
        else:
            flat_data[pixel] = set_bit(value, secret_bit, False)
        idx += 1
    return flat_data.reshape(orig_shape)


def set_bit(octet: int, bit: int, value: bool) -> int:
    mask = 1 << bit
    octet &= ~mask
    if value:
        octet |= mask
    return octet


def get_bit(octet: int, bit: int) -> bool:
    value = octet >> bit
    value &= 1
    return bool(value)


def main(img_in: Path, img_out: Path, msg: str) -> None:
    print("Message to hide:", msg)
    msg_bits = text_to_bits(msg)
    # Read img file
    img_content = read_file(img_in)
    # Check message will fit in image file
    # print(max_msg_len(img_content), len(msg), msg_bits)
    if len(msg) > max_msg_len(img_content):
        print(
            f"Message too long for image file. "
            f"Can only have {max_msg_len(img_content)} characters"
        )
        exit()
    # Modify data
    new_data = embed_message(img_content, msg_bits)
    # Check message can be extracted
    extracted_bits = extract_message(new_data)
    print("Message in new image:", bits_to_text(extracted_bits))
    # Save to file
    write_file(img_out, new_data)
    # Read from secret file
    img_content = read_file(img_out)
    read_bits = extract_message(img_content)
    print(f"From {img_out.name} read: {bits_to_text(read_bits)}")


if __name__ == "__main__":
    # Files
    data_dir = Path(__file__).parent.joinpath("data")
    original_png = data_dir.joinpath("gnome-xterm.png")
    secret_png = data_dir.joinpath("secret.png")
    # Message
    txt_to_hide = "secret message to hide hehehe"
    main(original_png, secret_png, txt_to_hide)

Message to hide: secret message to hide hehehe
Message in new image: secret message to hide hehehe
From secret.png read: secret message to hide hehehe