1
from PIL import Image
2
import os

1
input_directory = 'input_images/'
2
output_directory = 'output_images/'
3
watermark_path = 'watermark.png' # Use a PNG with transparency for best results

1
if not os.path.exists(output_directory):
2
    os.makedirs(output_directory)

1
try:
2
    watermark = Image.open(watermark_path).convert("RGBA")
3
except FileNotFoundError:
4
    print(f"Error: Watermark file not found at {watermark_path}")
5
    exit()

1
for filename in os.listdir(input_directory):
2
    if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.gif')): # Process common image types
3
        image_path = os.path.join(input_directory, filename)
4
        output_path = os.path.join(output_directory, filename)
5

6
        try:
7
            img = Image.open(image_path).convert("RGBA") # Convert main image to RGBA
8
        except Exception as e:
9
            print(f"Could not open or process file {filename}: {e}")
10
            continue # Skip to the next file
11

12
        # ... (watermarking logic goes here) ...
13

14
        # Save the watermarked image
15
        try:
16
            # Ensure format is compatible (e.g., convert back to RGB if saving as JPG)
17
            if img.mode == 'RGBA' and (output_path.lower().endswith('.jpg') or output_path.lower().endswith('.jpeg')):
18
                 img = img.convert('RGB')
19
            img.save(output_path)
20
            print(f"Watermarked and saved {filename}")
21
        except Exception as e:
22
            print(f"Could not save watermarked file {filename}: {e}")

1
        # Calculate watermark size relative to image
2
        img_width, img_height = img.size
3
        watermark_width, watermark_height = watermark.size
4

5
        # Example: Resize watermark to 15% of image width
6
        new_watermark_width = int(img_width * 0.15)
7
        if new_watermark_width == 0: new_watermark_width = 1 # Ensure minimum size
8
        new_watermark_height = int(watermark_height * (new_watermark_width / watermark_width))
9

10
        # Resize watermark - use LANCZOS for high-quality downsampling
11
        resized_watermark = watermark.resize((new_watermark_width, new_watermark_height), Image.Resampling.LANCZOS)
12

13
        # Calculate position (e.g., bottom-right with padding)
14
        padding = 20 # pixels
15
        position_x = img_width - new_watermark_width - padding
16
        position_y = img_height - new_watermark_height - padding
17

18
        # Ensure position is within image bounds
19
        position_x = max(0, position_x)
20
        position_y = max(0, position_y)
21

22
        # Use a tuple for the position
23
        position = (position_x, position_y)

1
        # Apply the watermark to the image
2
        # The mask parameter tells paste to use the watermark's alpha channel
3
        img.paste(resized_watermark, position, resized_watermark)

1
from PIL import Image
2
import os
3

4
def automate_watermarking(input_dir, output_dir, watermark_path, padding=20, watermark_size_ratio=0.15):
5
    """
6
    Automates applying a watermark to all images in a directory.
7

8
    Args:
9
        input_dir (str): Path to the directory containing original images.
10
        output_dir (str): Path to the directory to save watermarked images.
11
        watermark_path (str): Path to the watermark image file (preferably PNG with transparency).
12
        padding (int): Padding in pixels from the image edge for watermark placement.
13
        watermark_size_ratio (float): Ratio of the watermark width to the main image width (0.0 to 1.0).
14
    """
15
    # Ensure output directory exists
16
    if not os.path.exists(output_dir):
17
        os.makedirs(output_dir)
18
        print(f"Created output directory: {output_dir}")
19

20
    # Load the watermark image
21
    try:
22
        watermark = Image.open(watermark_path).convert("RGBA")
23
        print(f"Successfully loaded watermark: {watermark_path}")
24
    except FileNotFoundError:
25
        print(f"Error: Watermark file not found at {watermark_path}")
26
        return # Exit the function if watermark is not found
27
    except Exception as e:
28
        print(f"Error loading watermark file {watermark_path}: {e}")
29
        return
30

31
    print(f"Starting watermarking process for images in {input_dir}...")
32

33
    # Iterate through input images
34
    processed_count = 0
35
    for filename in os.listdir(input_dir):
36
        # Check if the file is a common image type
37
        if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.gif')):
38
            image_path = os.path.join(input_dir, filename)
39
            output_path = os.path.join(output_dir, filename)
40

41
            # Skip if output file already exists (optional)
42
            # if os.path.exists(output_path):
43
            #     print(f"Skipping {filename}: Output file already exists.")
44
            #     continue
45

46
            try:
47
                img = Image.open(image_path).convert("RGBA") # Convert main image to RGBA
48
                img_width, img_height = img.size
49

50
                # Calculate watermark size relative to image
51
                watermark_width, watermark_height = watermark.size
52
                new_watermark_width = int(img_width * watermark_size_ratio)
53
                # Prevent watermark from being too small or causing division by zero
54
                if new_watermark_width == 0: new_watermark_width = 1
55
                # Maintain aspect ratio
56
                try:
57
                    new_watermark_height = int(watermark_height * (new_watermark_width / watermark_width))
58
                    if new_watermark_height == 0: new_watermark_height = 1
59
                except ZeroDivisionError:
60
                     new_watermark_height = new_watermark_width # Handle case where watermark_width was 0
61

62
                # Resize watermark
63
                resized_watermark = watermark.resize((new_watermark_width, new_watermark_height), Image.Resampling.LANCZOS)
64

65
                # Calculate position (e.g., bottom-right with padding)
66
                position_x = img_width - new_watermark_width - padding
67
                position_y = img_height - new_watermark_height - padding
68

69
                # Ensure position is within image bounds (handle small images)
70
                position_x = max(0, position_x)
71
                position_y = max(0, position_y)
72
                position = (position_x, position_y)
73

74
                # Apply the watermark
75
                img.paste(resized_watermark, position, resized_watermark)
76

77
                # Save the watermarked image
78
                # Handle saving based on original file extension
79
                try:
80
                    original_extension = os.path.splitext(filename)[1].lower()
81
                    if original_extension in ('.jpg', '.jpeg'):
82
                        # Save JPEGs without transparency
83
                        if img.mode == 'RGBA':
84
                            img = img.convert('RGB')
85
                        img.save(output_path, format='JPEG', quality=90) # Specify quality for JPEG
86
                    elif original_extension == '.png':
87
                         img.save(output_path, format='PNG') # PNG supports transparency
88
                    else:
89
                         # For other formats, just save
90
                         img.save(output_path)
91

92
                    print(f"Successfully watermarked and saved: {filename}")
93
                    processed_count += 1
94

95
                except Exception as e:
96
                    print(f"Error saving watermarked file {filename}: {e}")
97

98
            except Exception as e:
99
                print(f"Could not open, process, or watermark file {filename}: {e}")
100
                continue # Skip to the next file
101

102
    print(f"Watermarking process completed. Processed {processed_count} images.")
103

104
# Example usage:
105
# Create 'input_images' and 'output_images' directories
106
# Place original images in 'input_images'
107
# Place your 'watermark.png' file in the same directory as the script, or specify its path
108
# automate_watermarking('input_images/', 'output_images/', 'watermark.png')