Watermarking is a technique used to embed information into an image, which can be used for various purposes such as copyright protection, authentication, or non-repudiation. In this guide, we will explore the basics of image watermarking and how you can implement it in your projects.

Why Use Watermarking?

Basic Techniques for Watermarking

1. Visible Watermarking

One of the simplest methods of watermarking is to alter the pixel values of an image. This is usually done for copyright protection or branding purposes. The watermark can be a logo, text, or any other image that is blended with the original image. This type of watermarking is immediately noticeable and can be readily removed by someone with image editing skills, but it serves as a visible deterrent against unauthorized use.

2. Least Significant Bit (LSB) Insertion

Least significant bit insertion is a subset of steganography where a hidden message is imbedded into an image to bypass detection. The simplest method involves modifying the least significant bits (LSBs) of pixel values, which allows for a more robust and imperceptible watermark.

3. Frequency Domain Manipulation

This method involves transforming the image into the frequency domain using techniques like the Discrete Cosine Transform (DCT) or Discrete Wavelet Transform (DWT). Watermarks can then be embedded in the frequency coefficients, which are not visible to the human eye.

These techniques are more complex but provide better security and robustness against attacks such as cropping, resizing, or compression. We will cover the DWT in a more advanced quide.

Least Significant Bit Watermarking

To implement the simplest form of invisible watermarking in your images, you can use the cv2 library in Python to read in the image and modify the last bits of each pixel.

 1import cv2
 2
 3def embed_lsb(image_path, message, output_path):
 4    image = cv2.imread(image_path)
 5    flat = image.flatten()
 6
 7    # Convert message to binary
 8    bits = ''.join([format(ord(i), '08b') for i in message]) + '00000000'  # Null terminator
 9    for i in range(len(bits)):
10        flat[i] = (flat[i] & ~1) | int(bits[i])  # Set LSB
11
12    watermarked = flat.reshape(image.shape)
13    cv2.imwrite(output_path, watermarked)
14
15def extract_lsb(image_path):
16    # Load image and flatten to 1D array
17    image = cv2.imread(image_path).flatten()
18    bits = ""
19    for byte in image:
20        bits += str(byte & 1)  # Get LSB
21
22        # Check every 8 bits for null terminator
23        if len(bits) % 8 == 0:
24            char = chr(int(bits[-8:], 2))
25            if char == '\x00':
26                break
27
28    # Convert full bitstring to characters (excluding null terminator)
29    message = ''.join(
30        chr(int(bits[i:i+8], 2)) for i in range(0, len(bits)-8, 8)
31    )
32    return message
33
34if __name__ == "__main__":
35
36    # Example usage
37    embed_lsb("image.png", "Secret Watermark", "output.png")
38
39    message = extract_lsb("image.png")
40    print("Extracted message:", message)
41
42    message = extract_lsb("output.png")
43    print("Extracted message:", message)

The embed_lsb function will take an image, a message, and an output path to save the watermarked image. The extract_lsb function will read the watermarked image and extract the hidden message. There are simpler was of doing this such as using a dedicated steganography library like stegano, but this example shows how you can implement it from scratch.

Stegano Code Example

 1from stegano import lsb
 2def embed_message(image_path, message, output_path):
 3    # Embed the message in the image
 4    watermarked_image = lsb.hide(image_path, message)
 5    watermarked_image.save(output_path)
 6
 7def extract_message(image_path):
 8    # Extract the message from the image
 9    return lsb.reveal(image_path)
10
11if __name__ == "__main__":
12    embed_message("image.png", "Secret Watermark", "watermarked_image.png")
13    message = extract_message("watermarked_image.png")
14    print("Extracted message:", message)

This is a much simpler way to achieve the same result and it abstracts away the details of how the LSB is manipulated. The stegano library handles the encoding and decoding of messages in images, making it easier to implement watermarking without needing to understand the underlying pixel manipulation. There are also other modules within stegano that allow for more complex watermarking techniques, such as using different color channels or even embedding multiple messages.

Watermarking Example

Reading the Watermark

To read the watermark from an image, you can reverse the process by extracting the pixel values or frequency coefficients where the watermark was embedded. This can be done using similar libraries and techniques as mentioned above.

Using the extract_lsb function