繁体   English   中英

Python:使用 openCV 保存(cv2.imwrite)和读取(cv2.imread)过程中的隐写问题

[英]Python: Problems of steganography in process of saving(cv2.imwrite) and reading(cv2.imread) using openCV

我有一个将图像隐藏在另一个图像中的隐写术代码。

我通过此代码将水印注入到我的图像中。

原理很简单。

我使用source_imagewatermark_images插入水印。

这将随机分配watermark_images

在此处输入图像描述

首先,使用随机种子分散水印图像的 x 和 y。

然后,使用快速傅里叶变换将source_image转换为频率区域。

最后,将watermark_layersource_image的频率区域结合起来。

在此处输入图像描述

此编码过程运行良好。 但是,在解码的过程中存在问题。

解码代码是按照相同的原理将随机种子分散在一个地方的像素收集起来。

这是解码的结果:

在此处输入图像描述

这个问题,如果我尝试将图像编码到保存(cv2.imwrite)并调用(cv2.imread),解码不起作用。

如果我按原样使用已编码的 object,则没有问题。 保存和调用过程中像素是否损坏?

这是我的完整代码:

import cv2 as cv
import numpy as np
import random
import time


class Watermark:
    def __init__(self):
        self.watermark_image = cv.imread('../Watermark/google_logo.png')
        self.result_image_path = '../Watermark/result.jpg'
        self.random_seed = 2021
        self.alpha = 5

    def encoding(self, image_path):
        # Code Start
        start_time = time.time()

        # Read Image
        source_image = cv.imread(image_path)
        source_height, source_width, _ = source_image.shape
        watermark_height, watermark_width, _ = self.watermark_image.shape

        print('source height : ', source_height, ', source_width : ', source_width)
        print('watermark height : ', watermark_height, ', watermark width : ', watermark_width)

        # Convert image to frequency area with Fast Fourier Transform (image -> frequency)
        source_frequency = np.fft.fft2(source_image)

        # Get random seed
        y_random_indices, x_random_indices = list(range(source_height)), list(range(source_width))
        random.seed(self.random_seed)
        random.shuffle(x_random_indices)
        random.shuffle(y_random_indices)

        print('y random seed : ', y_random_indices)
        print('x random seed : ', x_random_indices)

        # Injection watermark
        watermark_layer = np.zeros(source_image.shape, dtype=np.uint8)
        for y in range(watermark_height):
            for x in range(watermark_width):
                watermark_layer[y_random_indices[y], x_random_indices[x]] = self.watermark_image[y, x]

        # Encoding frequency area + watermark layer
        result_frequency = source_frequency + self.alpha * watermark_layer

        # Apply Inverse Fast Fourier Transform (frequency -> image)
        result_image = np.fft.ifft2(result_frequency)
        result_image = np.real(result_image)
        result_image = result_image.astype(np.uint8)

        # Show elapsed time
        end_time = time.time()
        print('Encoding elapsed time : ', end_time - start_time, '\n')

        # Visualization
        cv.imshow('source_image', source_image)
        cv.imshow('watermark', self.watermark_image)
        cv.imshow('watermark_layer', watermark_layer)
        cv.imshow('result_image', result_image)

        # Save and Close
        cv.imwrite(self.result_image_path, result_image)
        cv.waitKey(0)
        cv.destroyAllWindows()

        return result_image

    def decoding(self, source_image_path, encoded_image):
        # Code Start
        start_time = time.time()

        # Read Image
        source_image = cv.imread(source_image_path)

        source_height, source_width, _ = source_image.shape
        print('original_height : ', source_height)
        print('original_width : ', source_width)

        encoded_height, encoded_width, _ = encoded_image.shape

        # Convert image to frequency area with Fast Fourier Transform (image -> frequency)
        source_frequency = np.fft.fft2(source_image)
        encoded_frequency = np.fft.fft2(encoded_image)

        # Convert frequency area to image (frequency -> image)
        watermark_layer = (source_frequency - encoded_frequency) / self.alpha
        watermark_layer = np.real(watermark_layer).astype(np.uint8)

        # Get random seed
        y_random_indices, x_random_indices = [list(range(encoded_height)), list(range(encoded_width))]
        random.seed(self.random_seed)
        random.shuffle(x_random_indices)
        random.shuffle(y_random_indices)

        print('y random seed : ', y_random_indices)
        print('x random seed : ', x_random_indices)

        # Restore watermark
        result_image = np.zeros(watermark_layer.shape, dtype=np.uint8)

        for y in range(encoded_height):
            for x in range(encoded_width):
                result_image[y, x] = watermark_layer[y_random_indices[y], x_random_indices[x]]

        # Show elapsed time
        end_time = time.time()
        print('Encoding elapsed time : ', end_time - start_time, '\n')

        # Visualization
        cv.imshow('original image', source_image)
        cv.imshow('target image', encoded_image)
        cv.imshow('watermark layer', watermark_layer)
        cv.imshow('result image', result_image)
        cv.waitKey(0)
        cv.destroyAllWindows()


if __name__ == '__main__':
    source_path = '../Watermark/jennie.jpg'

    # good work
    protected_image = Watermark().encoding(source_path)
    Watermark().decoding(source_path, protected_image)

    # doesn't work
    result_path = '../Watermark/result.jpg'
    result_image = cv.imread(result_path)
    Watermark().decoding(source_path, result_image)

请给我一些建议。

Carlos Melus 有一个很好的观点。

您的代码不适合处理 jpg 图像。

如果你使用 png 格式,效果会很好。

暂无
暂无

声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.

 
粤ICP备18138465号  © 2020-2024 STACKOOM.COM