Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 WildChat-4.8M (AI2)

from PIL import Image import numpy as np import math def calculateparity(block):…

  1. User

    from PIL import Image import numpy as np import math

    def calculate_parity(block): flat_block = block.flatten() ret = sum(flat_block) % 2 return ret

    def invert_lsb(value): return value ^ 1

    def bmp_steganography_encode(input_image_path, output_image_path, secret_data_file_path): image = Image.open(input_image_path) pixels = np.array(image)

    with open(secret_data_file_path, 'r') as file:
        secret_data = file.read()
    secret_data += '#'
    
    binary_secret_data = ''.join(format(ord(i), '08b') for i in secret_data)
    binary_secret_length = len(binary_secret_data)
    
    num_columns = pixels.shape[1]
    if binary_secret_length <= num_columns:
        block_height = pixels.shape[0]
        blocks_per_column = 1
    else:
        blocks_per_column = math.ceil(binary_secret_length / num_columns)
        block_height = math.ceil(pixels.shape[0] / blocks_per_column)
    
    data_index = 0
    
    for col in range(num_columns):
        if data_index >= binary_secret_length:
            break
    
        for block_index in range(blocks_per_column):
            if data_index >= binary_secret_length:
                break
    
            start_row = block_index * block_height
            end_row = min(start_row + block_height, pixels.shape[0])
    
            block = pixels[start_row:end_row, col, :3]
    
            parity_bit = calculate_parity(block)
    
            secret_bit = int(binary_secret_data[data_index])
    
            if parity_bit != secret_bit:
                for i in range(block.shape[0]):
                    for k in range(3):
                        block[i, k] = invert_lsb(block[i, k])
                        parity_bit = calculate_parity(block)
                        if parity_bit == secret_bit:
                            break
                    if parity_bit == secret_bit:
                        break
    
            pixels[start_row:end_row, col, :3] = block
    
            data_index += 1
    
    new_image = Image.fromarray(pixels)
    new_image.save(output_image_path)
    
    print(f"Количество вставленных бит: {binary_secret_length}")
    return blocks_per_column
    

    def bmp_steganography_decode(input_image_path, blocks_per_column = 1): if blocks_per_column < 1 or blocks_per_column > 1000: raise Exception("Invalid value!") try: image = Image.open(input_image_path) pixels = np.array(image)

        num_rows, num_columns = pixels.shape[:2]
    
        block_height = math.ceil(pixels.shape[0] / blocks_per_column)
    
        binary_data = ""
        for col in range(num_columns):
            start_row = 0
    
            for block_index in range(blocks_per_column):
                # Определяем границы блока
                start_row = block_index * block_height
                end_row = min(start_row + block_height, pixels.shape[0])
    
                block = pixels[start_row:end_row, col, :3]
    
                parity_bit = calculate_parity(block)
    
                binary_data += str(parity_bit)
    
    except Exception as e:
        print("Error", f"Failed to read the file: {str(e)}")
    finally:
        all_bytes = [binary_data[i:i + 8] for i in range(0, len(binary_data), 8)]
        decoded_data = ""
        for byte in all_bytes:
            if byte:
                decoded_data += chr(int(byte, 2))
                if decoded_data.endswith("#"):
                    break
        return decoded_data.rstrip("#")
    

    def calculate_psnr(img1, img2, max_value=255): mse = np.mean((np.array(img1, dtype=np.float32) - np.array(img2, dtype=np.float32)) ** 2) if mse == 0: return 100 return 20 * np.log10(max_value / (np.sqrt(mse)))

    if name == "main": print("Выберите операцию:") print("1: Внедрение") print("2: Извлечение") print("3: Расчет PSNR")

    choice = input("Введите номер операции: ")
    
    if choice == "1":
        input_image_path = input("Введите путь к файлу-контейнеру (.bmp): ")
        output_image_path = input("Введите путь к выходному файлу (.bmp): ")
        secret_data_file_path = input("Введите путь к текстовому файлу с секретным сообщением (.txt): ")
    
        blocks_per_column = bmp_steganography_encode(input_image_path, output_image_path, secret_data_file_path)
        print(f"Сообщение закодировано успешно! Количество блоков на столбец: {blocks_per_column}")
        
    elif choice == "2":
        input_image_path = input("Введите путь к выходному файлу-контейнеру (.bmp): ")
        blocks_per_column = int(input("Введите коэффициент разделения (x): "))
        
        decoded_message = bmp_steganography_decode(input_image_path, blocks_per_column)
        print("Извлеченное из контейнера сообщение:", decoded_message)
        
    elif choice == "3":
        input_image_path1 = input("Введите путь к исходному файлу-контейнеру (.bmp): ")
        input_image_path2 = input("Введите пусть к файлу-контейнеру со внедренной информацией (.bmp): ")
        
        img1 = Image.open(input_image_path1)
        img2 = Image.open(input_image_path2)
        
        psnr_value = calculate_psnr(img1, img2)
        print(f"Значение PSNR между двумя изображениями: {psnr_value}")
    else:
        print("Неверный выбор!")
    

    дай полное объяснение кода

  2. Assistant

    Этот код реализует простую форму стеганографии, позволяющую встраивать скрытые сообщения в изображения формата BMP с использованием наименьших значащих битов (LSB). Расшифровка спроектирована для извлечения закодированных сообщений обратно.

    Давайте разберем код по частям:

    Импорт библиотек

    from PIL import Image
    import numpy as np
    import math
    
    • PIL (Pillow) используется для работы с изображениями.
    • NumPy позволяет более эффективно работать с массивами данных, в данном случае - с пикселями изображения.
    • math используется для выполнения математических вычислений, например, для округления.

    Функции

    1. calculate_parity(block)

    Эта функция вычисляет четность (parity) блока пикселей. Параметр block - это блок изображений, и функция:

    • Преобразует его в одномерный массив.
    • Суммирует все значения и возвращает остаток от деления на 2 (чётное или нечётное).

    2. invert_lsb(value)

    Эта функция инвертирует наименьший значащий бит (LSB) переданного значения value с помощью побитового исключающего ИЛИ (^).

    3. bmp_steganography_encode(...)

    Эта функция выполняет кодирование (внедрение) секретного сообщения в изображение:

    • Загружает изображение и его пиксели.
    • Читает текстовый файл с секретным сообщением, добавляет к нему символ конца сообщения (#).
    • Преобразует секретные данные в строку двоичных значений.
    • Определяет, сколько блоков пикселей необходимо для внедрения данных в зависимости от размера исходного изображения и количества битов сообщения.
    • Встраивает биты в изображение. Для каждого столбца:
      • Получает блок пикселей.
      • Вычисляет четность блока.
      • Если четность не соответствует секретному биту, модифицируются значения пикселей для корректировки четности. Инвертируется наименьший значащий бит некоторых пикселей, пока четность не станет равной секретному биту.
    • Сохраняет измененное изображение.

    4. bmp_steganography_decode(...)

    Эта функция извлекает закодированное сообщение из изображения:

    • Загружает изображение и пиксели.
    • Обрабатывает каждый столбец пикселей в блоки и вычисляет четность.
    • Составляет строку двоичных данных, декодируя их в символы.
    • Возвращает извлеченное сообщение до символа конца (#).

    5. calculate_psnr(img1, img2, max_value=255)

    Эта функция рассчитывает Peak Signal-to-Noise Ratio (PSNR) между двумя изображениями:

    • Вычисляет среднеквадратичную ошибку (MSE) между изображениями.
    • Если MSE равно 0, PSNR будет 100 (изображения одинаковы).
    • Возвращает значение PSNR.

    Основная программа

    if __name__ == "__main__":
    

    Выбор операции:

    • Вставка данных в изображение (внедрение).

    • Извлечение закодированных данных.

    • Расчет PSNR для оценки качества изображения до и после внедрения.

    • Программа запрашивает нужные пути к файлам и вызывает соответствующие функции на основе выбора пользователя. Сначала она запрашивает входные данные о Bild ( контейнере ) и текстовом файле, затем в зависимости от выбора выполняет внедрение или извлечение сообщения.

    Общий принцип работы

    1. Пользователь выбирает, что сделать: внедрить сообщение в изображение, извлечь сообщение из изображения или рассчитать PSNR.
    2. В случае внедрения сообщение помещается в изображение, изменяя наименьшие значащие биты пикселей с учетом четности.
    3. Извлечение происходит путем чтения четности битов и преобразования их обратно в символы.
    4. PSNR помогает понять, насколько сильно изменилось изображение после внедрения данных.

    Заключение

    Эта программа иллюстрирует базовые принципы стеганографии с использованием наименьших значащих битов и позволяет как внедрять сообщения в изображения, так и извлекать их, делая это достаточно эффективно для изображения в формате BMP.

  3. User

    построчно

  4. Assistant

    Давайте пройдемся по коду построчно и объясним каждую строку.

    Импорт библиотек

    from PIL import Image
    import numpy as np
    import math
    
    • from PIL import Image: Импортируем класс Image из библиотеки Pillow для работы с изображениями.
    • import numpy as np: Импортируем библиотеку NumPy для работы с многомерными массивами, что особенно полезно для работы с пикселями изображений.
    • import math: Импортируем модуль math, чтобы использовать математические функции.

    Функция calculate_parity

    def calculate_parity(block):
    
    • Определяем функцию calculate_parity, которая принимает параметр block, представляющий собой массив пикселей.
        flat_block = block.flatten()
    
    • Преобразуем 2D-массив пикселей в одномерный массив для упрощения обработки.
        ret = sum(flat_block) % 2
    
    • Суммируем все значения в плоском массиве и вычисляем остаток от деления на 2, чтобы узнать четность (0 - четное, 1 - нечетное).
        return ret
    
    • Возвращаем вычисленную четность.

    Функция invert_lsb

    def invert_lsb(value):
    
    • Определяем функцию invert_lsb, которая принимает параметр value.
        return value ^ 1
    
    • Возвращаем значение, где последний бит value инвертирован при помощи побитового исключающего ИЛИ (^).

    Функция bmp_steganography_encode

    def bmp_steganography_encode(input_image_path, output_image_path, secret_data_file_path):
    
    • Объявляем функцию для внедрения (кодирования) данных, принимающую три параметра:
      1. input_image_path: путь к исходному изображению.
      2. output_image_path: путь к выходному изображению.
      3. secret_data_file_path: путь к текстовому файлу с секретными данными.
        image = Image.open(input_image_path)
    
    • Загружаем изображение из указанного пути.
        pixels = np.array(image)
    
    • Преобразуем изображение в массив пикселей NumPy для удобной обработки.
        with open(secret_data_file_path, 'r') as file:
            secret_data = file.read()
    
    • Считываем содержимое текстового файла в переменную secret_data.
        secret_data += '#'
    
    • Добавляем символ завершения (#) к секретным данным, чтобы обозначить конец сообщения.
        binary_secret_data = ''.join(format(ord(i), '08b') for i in secret_data)
    
    • Преобразуем каждую букву в двоичный формат (8 бит) и объединяем в одну строку двоичных данных.
        binary_secret_length = len(binary_secret_data)
    
    • Вычисляем длину двоичной строки с секретными данными.
        num_columns = pixels.shape[1]
    
    • Получаем количество столбцов (ширину) изображения.
        if binary_secret_length <= num_columns:
            block_height = pixels.shape[0]
            blocks_per_column = 1
    
    • Если длина двоичной строки меньше или равна количеству столбцов, устанавливаем высоту блока в высоту изображения и количество блоков за один столбец в 1.
        else:
            blocks_per_column = math.ceil(binary_secret_length / num_columns)
            block_height = math.ceil(pixels.shape[0] / blocks_per_column)
    
    • Если длина двоичной строки больше количества столбцов, рассчитываем количество блоков для столбца и высоту блока.
        data_index = 0
    
    • Инициализируем индекс данных для отслеживания текущего бита из двоичной строки.

    Внедрение данных

        for col in range(num_columns):
            if data_index >= binary_secret_length:
                break
    
    • Проходим по каждому столбцу и выходим из цикла, если индекс данных превышает длину двоичных данных.
            for block_index in range(blocks_per_column):
                if data_index >= binary_secret_length:
                    break
    
    • Для каждого столбца проходим по блокам и выходим из цикла, если индекс данных превышает длину данных.
                start_row = block_index * block_height
                end_row = min(start_row + block_height, pixels.shape[0])
    
    • Рассчитываем начальную и конечную строки текущего блока по индексу.
                block = pixels[start_row:end_row, col, :3]
    
    • Извлекаем блок пикселей из определенной области (вырезаем по строкам и берём цветовые каналы RGB).
                parity_bit = calculate_parity(block)
    
    • Вычисляем четность блока.
                secret_bit = int(binary_secret_data[data_index])
    
    • Получаем соответствующий бит из двоичных данных.
                if parity_bit != secret_bit:
    
    • Если четность блока не совпадает с секретным битом, начинаем изменять пиксели.
                    for i in range(block.shape[0]):
                        for k in range(3):
    
    • Проходим по всем пикселям случайного блока и его цветовым каналам.
                            block[i, k] = invert_lsb(block[i, k])
    
    • Инвертируем LSB для текущего канала пикселя.
                            parity_bit = calculate_parity(block)
    
    • Рассчитываем новую четность блока после изменения.
                            if parity_bit == secret_bit:
                                break
    
    • Если новая четность совпадает с секретным битом, выходим из цикла.
                        if parity_bit == secret_bit:
                            break
    
    • Проверяем, нашли ли мы нужный бит и выходим из внешнего цикла, если смена LSB уже прошла.
                pixels[start_row:end_row, col, :3] = block
    
    • Записываем измененный блок обратно в массив пикселей.
                data_index += 1
    
    • Увеличиваем индекс данных, чтобы перейти к следующему биту.

    Сохранение нового изображения

        new_image = Image.fromarray(pixels)
    
    • Преобразуем измененный массив пикселей обратно в изображение.
        new_image.save(output_image_path)
    
    • Сохраняем новое изображение с внедренными данными.
        print(f"Количество вставленных бит: {binary_secret_length}")
        return blocks_per_column
    
    • Выводим количество вставленных бит и возвращаем число блоков на столбец.

    Функция bmp_steganography_decode

    def bmp_steganography_decode(input_image_path, blocks_per_column = 1):
    
    • Объявляем функцию для извлечения данных, принимающую путь к изображению и количество блоков на столбец.
        if blocks_per_column < 1 or blocks_per_column > 1000:
            raise Exception("Invalid value!")
    
    • Проверяем допустимый диапазон для числа блоков и выбрасываем исключение, если значение вне диапазона.
        try:
            image = Image.open(input_image_path)
    
    • Загрузка изображения и инициализация блока try для обработки исключений.
            pixels = np.array(image)
    
    • Преобразование изображения в массив пикселей.
            num_rows, num_columns = pixels.shape[:2]
    
    • Получение количества строк и столбцов в изображении.
            block_height = math.ceil(pixels.shape[0] / blocks_per_column)
    
    • Рассчитываем высоту блока, основываясь на общем количестве строк.
            binary_data = ""
    
    • Инициализация строки для сборки двоичных данных.
            for col in range(num_columns):
                start_row = 0
    
    • Проходим по каждому столбцу, инициализируя start_row.
                for block_index in range(blocks_per_column):
    
    • Проходим по количеству блоков в данном столбце.
                    start_row = block_index * block_height
                    end_row = min(start_row + block_height, pixels.shape[0])
    
    • Определяем начальную и конечную строки блока.
                    block = pixels[start_row:end_row, col, :3]
    
    • Извлекаем блок пикселей для обработки.
                    parity_bit = calculate_parity(block)
    
    • Вычисляем четность блока.
                    binary_data += str(parity_bit)
    
    • Добавляем четность блока к строке двоичных данных.
        except Exception as e:
            print("Error", f"Failed to read the file: {str(e)}")
    
    • В случае возникновения ошибки выводим сообщение об ошибке.
        finally:
            all_bytes = [binary_data[i:i + 8] for i in range(0, len(binary_data), 8)]
    
    • Создаем список байтов из двоичной строки, разбивая ее по 8 бит.
            decoded_data = ""
            for byte in all_bytes:
    
    • Инициализируем строку для хранения извлечённого сообщения и проходим по каждому байту.
                if byte:
                    decoded_data += chr(int(byte, 2))
    
    • Если байт не пуст, преобразуем его из двоичного в символ и добавляем к строке decoded_data.
                    if decoded_data.endswith("#"):
                        break
    
    • Прерываем цикл, если конец сообщения (#) найден.
            return decoded_data.rstrip("#")
    
    • Возвращаем извлеченное сообщение без символа конца.

    Функция calculate_psnr

    def calculate_psnr(img1, img2, max_value=255):
    
    • Объявляем функцию для вычисления PSNR, принимающую два изображения и максимальное значение яркости (по умолчанию 255).
        mse = np.mean((np.array(img1, dtype=np.float32) - np.array(img2, dtype=np.float32)) ** 2)
    
    • Вычисляем среднеквадратичную ошибку (MSE) между двумя изображениями. Разность изображений возводится в квадрат, вычисляется среднее.
        if mse == 0:
            return 100
    
    • Если MSE равно 0 (изображения идентичны), возвращаем 100.
        return 20 * np.log10(max_value / (np.sqrt(mse)))
    
    • Возвращаем значение PSNR, рассчитывая его по формуле.

    Основная программа

    if __name__ == "__main__":
    
    • Запускаем основной код при исполнении файла.
        print("Выберите операцию:")
        print("1: Внедрение")
        print("2: Извлечение")
        print("3: Расчет PSNR")
    
    • Выводим меню для выбора операции.
        choice = input("Введите номер операции: ")
    
    • Считываем выбор пользователя.
        if choice == "1":
    
    • Если выбран вариант для внедрения данных:
            input_image_path = input("Введите путь к файлу-контейнеру (.bmp): ")
            output_image_path = input("Введите путь к выходному файлу (.bmp): ")
            secret_data_file_path = input("Введите путь к текстовому файлу с секретным сообщением (.txt): ")
    
    • Запрашиваем пути к файлам.
            blocks_per_column = bmp_steganography_encode(input_image_path, output_image_path, secret_data_file_path)
    
    • Вызываем функцию для внедрения и получаем количество блоков на столбец.
            print(f"Сообщение закодировано успешно! Количество блоков на столбец: {blocks_per_column}")
    
    • Уведомляем пользователя о успешном кодировании.
        elif choice == "2":
    
    • Если выбран вариант для извлечения данных:
            input_image_path = input("Введите путь к выходному файлу-контейнеру (.bmp): ")
            blocks_per_column = int(input("Введите коэффициент разделения (x): "))
    
    • Запрашиваем пути к файлам и число блоков.
            decoded_message = bmp_steganography_decode(input_image_path, blocks_per_column)
    
    • Вызываем функцию для извлечения данных.
            print("Извлеченное из контейнера сообщение:", decoded_message)
    
    • Выводим извлеченное сообщение.
        elif choice == "3":
    
    • Если выбран вариант для вычисления PSNR:
            input_image_path1 = input("Введите путь к исходному файлу-контейнеру (.bmp): ")
            input_image_path2 = input("Введите пусть к файлу-контейнеру со внедренной информацией (.bmp): ")
    
    • Запрашиваем пути к исходному и измененному файлам.
            img1 = Image.open(input_image_path1)
            img2 = Image.open(input_image_path2)
    
    • Загружаем два изображения.
            psnr_value = calculate_psnr(img1, img2)
    
    • Вычисляем PSNR между изображениями.
            print(f"Значение PSNR между двумя изображениями: {psnr_value}")
    
    • Выводим значение PSNR.
        else:
            print("Неверный выбор!")
    
    • Если пользователь ввел неверный выбор, выводим сообщение об ошибке.

    Заключение

    Этот код реализует функции стеганографии для вставки и извлечения скрытых сообщений в изображениях, а также предоставляет возможность вычисления качества изображений по PSNR. Каждая часть кода играет свою роль в процессе, оптимизируя взаимодействие между изображениями и текстовыми данными.

  5. User

    напиши новый код с полными комментариями

  6. Assistant

    Конечно! Давайте создадим новый код для реализации стеганографии в изображениях с полными комментариями к каждому блоку кода. В этом примере будет реализована аналогичная функциональность: внедрение и извлечение текста в изображение формата BMP с использованием наименьших значащих битов (LSB).

    Вот новый код с полными комментариями:

    from PIL import Image           # Импортируем класс Image из библиотеки Pillow для работы с изображениями
    import numpy as np              # Импортируем NumPy для работы с массивами
    import math                     # Импортируем math для выполнения математических вычислений
    
    def calculate_parity(block):
        """
        Вычисляет четность для заданного блока пикселей.
        
        Параметры:
        block (ndarray): Массив пикселей (например, блок изображений).
        
        Возвращает:
        int: Четность блока (0 или 1).
        """
        flat_block = block.flatten()  # Преобразуем блок в одномерный массив
        return sum(flat_block) % 2    # Возвращаем остаток от деления на 2 (четность)
    
    def invert_lsb(value):
        """
        Инвертирует наименьший значащий бит (LSB) переданного значения.
        
        Параметры:
        value (int): Целое число, чье LSB нужно инвертировать.
        
        Возвращает:
        int: Значение с инвертированным LSB.
        """
        return value ^ 1              # Используем побитовое исключающее ИЛИ для инверсии LSB
    
    def bmp_steganography_encode(input_image_path, output_image_path, secret_data_file_path):
        """
        Кодирует (внедряет) секретное сообщение в изображение формата BMP.
        
        Параметры:
        input_image_path (str): Путь к исходному изображению.
        output_image_path (str): Путь для сохранения выходного изображения.
        secret_data_file_path (str): Путь к текстовому файлу с секретным сообщением.
        """
        # Загружаем изображение из указанного пути
        image = Image.open(input_image_path)
        pixels = np.array(image)  # Преобразуем изображение в массив пикселей
    
        # Читаем секретные данные из текстового файла
        with open(secret_data_file_path, 'r') as file:
            secret_data = file.read()
        secret_data += '#'  # Добавляем символ конца сообщения
    
        # Преобразуем секретные данные в двоичную строку
        binary_secret_data = ''.join(format(ord(i), '08b') for i in secret_data)
        binary_secret_length = len(binary_secret_data)  # Длина двоичной строки
    
        num_columns = pixels.shape[1]  # Получаем количество столбцов изображения
    
        # Определяем количество блоков на столбец и высоту блока
        if binary_secret_length <= num_columns:
            block_height = pixels.shape[0]
            blocks_per_column = 1
        else:
            blocks_per_column = math.ceil(binary_secret_length / num_columns)  # Общее количество блоков на столбец
            block_height = math.ceil(pixels.shape[0] / blocks_per_column)  # Высота блока
    
        data_index = 0  # Индекс для текущего бита двоичных данных
    
        # Проходим по каждому столбцу в изображении
        for col in range(num_columns):
            if data_index >= binary_secret_length:  # Если все биты уже вставлены, выходим
                break
    
            # Проходим по каждому блоку в текущем столбце
            for block_index in range(blocks_per_column):
                if data_index >= binary_secret_length:  # Если все биты уже вставлены, выходим
                    break
    
                start_row = block_index * block_height  # Начальная строка блока
                end_row = min(start_row + block_height, pixels.shape[0])  # Конечная строка блока
    
                block = pixels[start_row:end_row, col, :3]  # Извлекаем блок пикселей (RGB каналы)
    
                parity_bit = calculate_parity(block)  # Вычисляем пары для блока
                secret_bit = int(binary_secret_data[data_index])  # Получаем соответствующий бит из секретных данных
    
                if parity_bit != secret_bit:  # Если четность не совпадает с секретным битом
                    # Модифицируем пиксели для соответствия четности
                    for i in range(block.shape[0]):
                        for k in range(3):  # Проходим по каждому каналу цвета
                            block[i, k] = invert_lsb(block[i, k])  # Инвертируем LSB текущего канала
                            parity_bit = calculate_parity(block)  # Пересчитываем четность
                            if parity_bit == secret_bit:  # Если четность совпадает, выходим
                                break
                        if parity_bit == secret_bit:  # Если четность совпадает, выходим из внешнего цикла
                            break
    
                # Записываем модифицированный блок обратно в массив пикселей
                pixels[start_row:end_row, col, :3] = block
                data_index += 1  # Переходим к следующему биту двоичных данных
    
        # Создаем новое изображение из модифицированного массива пикселей
        new_image = Image.fromarray(pixels)
        new_image.save(output_image_path)  # Сохраняем новое изображение
    
        print(f"Количество вставленных бит: {binary_secret_length}")  # Выводим количество вставленных бит
        return blocks_per_column  # Возвращаем количество блоков на столбец
    
    def bmp_steganography_decode(input_image_path, blocks_per_column=1):
        """
        Извлекает секретное сообщение из изображения формата BMP.
        
        Параметры:
        input_image_path (str): Путь к входному изображению для декодирования.
        blocks_per_column (int): Количество блоков на столбец (по умолчанию 1).
        
        Возвращает:
        str: Извлеченное сообщение.
        """
        # Проверка на валидность входящих данных
        if blocks_per_column < 1 or blocks_per_column > 1000:
            raise Exception("Недопустимое значение!")
    
        try:
            # Загружаем изображение
            image = Image.open(input_image_path)
            pixels = np.array(image)  # Преобразуем изображение в массив пикселей
    
            num_rows, num_columns = pixels.shape[:2]  # Получаем размеры изображения
            block_height = math.ceil(num_rows / blocks_per_column)  # Рассчитываем высоту блока
            binary_data = ""  # Инициализируем строку для двоичных данных
    
            # Проходим по каждому столбцу изображения
            for col in range(num_columns):
                start_row = 0  # Инициализируем начальную строку
    
                # Проходим по блокам в текущем столбце
                for block_index in range(blocks_per_column):
                    start_row = block_index * block_height  # Начальная строка блока
                    end_row = min(start_row + block_height, num_rows)  # Конечная строка блока
                    block = pixels[start_row:end_row, col, :3]  # Получаем блок пикселей
    
                    parity_bit = calculate_parity(block)  # Вычисляем четность
                    binary_data += str(parity_bit)  # Добавляем бит четности к строке
    
        except Exception as e:
            print("Ошибка:", f"Не удалось прочитать файл: {str(e)}")  # Обработка исключений
    
        finally:
            # Делим строку двоичных данных на байты
            all_bytes = [binary_data[i:i + 8] for i in range(0, len(binary_data), 8)]
            decoded_data = ""  # Инициализируем строку для извлеченных символов
    
            # Проходим по всем байтам
            for byte in all_bytes:
                if byte:  # Проверяем, не пустой ли байт
                    decoded_data += chr(int(byte, 2))  # Преобразуем байт в символ
                    if decoded_data.endswith("#"):  # Проверяем на конец сообщения
                        break
    
            return decoded_data.rstrip("#")  # Возвращаем извлеченное сообщение без символа конца
    
    def calculate_psnr(img1, img2, max_value=255):
        """
        Рассчитывает Peak Signal-to-Noise Ratio (PSNR) между двумя изображениями.
        
        Параметры:
        img1 (Image): Первое изображение.
        img2 (Image): Второе изображение.
        max_value (int): Максимальное значение цвета (по умолчанию 255).
        
        Возвращает:
        float: Значение PSNR между двумя изображениями.
        """
        # Вычисляем среднеквадратичную ошибку (MSE)
        mse = np.mean((np.array(img1, dtype=np.float32) - np.array(img2, dtype=np.float32)) ** 2)
        if mse == 0:  # Если MSE равно 0 (изображения идентичны)
            return 100  # Возвращаем максимально возможное значение PSNR
        return 20 * np.log10(max_value / (np.sqrt(mse)))  # Возвращаем значение PSNR
    
    if __name__ == "__main__":
        print("Выберите операцию:")
        print("1: Внедрение")
        print("2: Извлечение")
        print("3: Расчет PSNR")
        
        choice = input("Введите номер операции: ")
        
        if choice == "1":  # Если выбрано действие для внедрения
            input_image_path = input("Введите путь к файлу-контейнеру (.bmp): ")
            output_image_path = input("Введите путь к выходному файлу (.bmp): ")
            secret_data_file_path = input("Введите путь к текстовому файлу с секретным сообщением (.txt): ")
    
            blocks_per_column = bmp_steganography_encode(input_image_path, output_image_path, secret_data_file_path)  # Кодируем сообщение
            print(f"Сообщение закодировано успешно! Количество блоков на столбец: {blocks_per_column}")
            
        elif choice == "2":  # Если выбрано действие для извлечения
            input_image_path = input("Введите путь к выходному файлу-контейнеру (.bmp): ")
            blocks_per_column = int(input("Введите коэффициент разделения (x): "))
            
            decoded_message = bmp_steganography_decode(input_image_path, blocks_per_column)  # Извлекаем сообщение
            print("Извлеченное из контейнера сообщение:", decoded_message)
            
        elif choice == "3":  # Если выбрано действие для расчета PSNR
            input_image_path1 = input("Введите путь к исходному файлу-контейнеру (.bmp): ")
            input_image_path2 = input("Введите путь к файлу-контейнеру со внедренной информацией (.bmp): ")
            
            img1 = Image.open(input_image_path1)  # Загружаем первое изображение
            img2 = Image.open(input_image_path2)  # Загружаем второе изображение
            
            psnr_value = calculate_psnr(img1, img2)  # Рассчитываем PSNR
            print(f"Значение PSNR между двумя изображениями: {psnr_value}")
            
        else:  # Если пользователь выбрал неверный вариант
            print("Неверный выбор!")
    

    Описание кода:

    1. Импорт библиотек: импортируются необходимые библиотеки для работы с изображениями и массивами.
    2. Функции:
      • calculate_parity: Рассчитывает четность для блока пикселей.
      • invert_lsb: Инвертирует наименьший значащий бит.
      • bmp_steganography_encode: Внедряет текст в изображение.
      • bmp_steganography_decode: Извлекает текст из изображения.
      • calculate_psnr: Рассчитывает PSNR между двумя изображениями.
    3. Основная программа: запускает интерфейс для выбора действия (внедрение, извлечение, расчет PSNR) и выполняет соответствующие функции на основе ввода пользователя.

    Этот код реализует простую стеганографию с поддержкой текстового ввода и анализ качества изображения с использованием PSNR, а все разделы кода подробно прокомментированы для лучшего понимания.