मेरे पास एक स्टेग्नोग्राफ़ी कोड है जो किसी अन्य छवि के अंदर छवि छुपा रहा है।

मैं इस कोड के माध्यम से अपनी छवि में वॉटरमार्क इंजेक्ट करता हूं।

सिद्धांत बहुत सरल है।

मैंने वॉटरमार्क डालने के लिए source_image और watermark_images का इस्तेमाल किया।

यह बेतरतीब ढंग से watermark_images वितरित करेगा।

enter image description here

सबसे पहले, यादृच्छिक बीजों का उपयोग करके वॉटरमार्क छवि के x और y को बिखेरें।

और फिर, फास्ट फूरियर ट्रांसफॉर्म का उपयोग करके source_image को फ़्रीक्वेंसी क्षेत्र में कनवर्ट करें।

अंत में, watermark_layer को source_image के बारंबारता क्षेत्र के साथ मिलाएं।

enter image description here

यह एन्कोडिंग प्रक्रिया पूरी तरह से अच्छी तरह से काम करती है। हालाँकि, डिकोडिंग की प्रक्रिया में एक समस्या है।

डिकोडिंग कोड एक ही सिद्धांत पर एक ही स्थान पर यादृच्छिक बीजों द्वारा बिखरे हुए पिक्सेल एकत्र करता है।

यह decoing का परिणाम है:

enter image description here

यह समस्या, अगर मैं सहेजने के लिए छवि को एन्कोड करने का प्रयास करता हूं (cv2.imwrite) और याद किया गया (cv2.imread), डिकोडिंग काम नहीं करता है।

अगर मैं एन्कोडेड ऑब्जेक्ट का उपयोग वैसे ही करता हूं, तो कोई समस्या नहीं है। क्या सहेजने और याद करने की प्रक्रिया के दौरान पिक्सेल क्षतिग्रस्त हो गया है?

यह मेरा पूरा कोड है:

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)

कृपया मुझे कुछ सुझाव दें।

1
user13912068 8 जिंदा 2021, 06:50
क्या आपने पीएनजी जैसे दोषरहित छवि प्रारूप का उपयोग करने की कोशिश की है? मुझे यकीन नहीं है कि jpg संपीड़न आपके एन्कोडिंग बीजों के साथ खिलवाड़ नहीं कर रहा है
 – 
Carlos Melus
8 जिंदा 2021, 07:04

1 उत्तर

सबसे बढ़िया उत्तर

कार्लोस मेलस के पास एक अच्छी बात है।

आपका कोड jpg छवियों को संसाधित करने के लिए उपयुक्त नहीं है।

यदि आप पीएनजी प्रारूप का उपयोग करते हैं, तो यह अच्छी तरह से काम करेगा।

0
Robot Jung 8 जिंदा 2021, 07:43