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.

    from PIL import Image
    import numpy as np
    import math
    
    # Функция для вычисления четности блока
    def calculate_parity(block):
        # Превращаем 2D блок в 1D массив (плоский)
        flat_block = block.flatten()
        # Возвращаем 1, если сумма значений нечетная, иначе 0
        return sum(flat_block) % 2
    
    # Функция для инверсии младшего бита
    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("#")  # Возвращаем декодированные данные без специального символа
    
    
    # Функция для расчёта PSNR (пикового соотношения сигнал/шум)
    def calculate_psnr(img1, img2, max_value=255):
        mse = np.mean((np.array(img1, dtype=np.float32) - np.array(img2, dtype=np.float32)) ** 2)  # Вычисляем MSE
        if mse == 0:
            return 100  # PSNR = 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}")
        else:
            print("Неверный выбор!")  # Обработка неверного выбора
    

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

  3. User

    дай более подробные комментарии в коде

  4. Assistant

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

    from PIL import Image  # Импортируем библиотеку для работы с изображениями
    import numpy as np  # Импортируем библиотеку для работы с массивами
    import math  # Импортируем математическую библиотеку для вычислений
    
    # Функция для вычисления четности блока пикселей
    def calculate_parity(block):
        # Превращаем 2D массив блоков в 1D массив (плоский)
        flat_block = block.flatten()  
        # Суммируем все значения пикселей и проверяем четность (возвращает 1, если сумма нечетная, иначе 0)
        return sum(flat_block) % 2  
    
    # Функция для инверсии младшего бита значения
    def invert_lsb(value):
        # Инвертируем последний бит (LSB) целого числа с помощью операции XOR с 1
        return value ^ 1  
    
    # Функция для внедрения скрытых данных в изображение в формате BMP
    def bmp_steganography_encode(input_image_path, output_image_path, secret_data_file_path):
        # Открываем входное изображение с помощью PIL
        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 += '#'  
    
        # Преобразуем каждую букву в бинарный формат (8-битное представление)
        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):  # Проходим по каналам (RGB) каждого пикселя
                            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  # Возвращаем количество блоков на столбец
    
    
    # Функция для извлечения скрытых данных из изображения в формате BMP
    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:
            # Разбиваем бинарные данные на байты по 8 бит
            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("#")  # Возвращаем декодированные данные без специального символа
    
    
    # Функция для расчета PSNR (пикового соотношения сигнал/шум)
    def calculate_psnr(img1, img2, max_value=255):
        # Вычисляем среднюю квадратичную ошибку (MSE) между двумя изображениями
        mse = np.mean((np.array(img1, dtype=np.float32) - np.array(img2, dtype=np.float32)) ** 2)  
        if mse == 0:
            return 100  # Если изображения идентичны, PSNR будет 100 дБ
        # Вычисляем PSNR с использованием формулы
        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":
            # Запрос данных для расчета PSNR
            input_image_path1 = input("Введите путь к исходному файлу-контейнеру (.bmp): ")  
            input_image_path2 = input("Введите путь к файлу-контейнеру со внедренной информацией (.bmp): ")  
            
            # Открываем изображения
            img1 = Image.open(input_image_path1)  
            img2 = Image.open(input_image_path2)  
            
            # Вычисляем PSNR между двумя изображениями
            psnr_value = calculate_psnr(img1, img2)  
            print(f"Значение PSNR между двумя изображениями: {psnr_value}")  # Выводим значение PSNR
        else:
            print("Неверный выбор!")  # Обрабатываем неверный выбор операции
    

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