Image Processing Script:
This Python script allows you to automatically process images by ensuring transparency, cropping unused spaces, resizing to fit a 2:1 canvas, and cleaning up the filenames. Here's what it does:
Transparency Handling: Ensures that images are in PNG format with transparency. If the image has a white background, it's replaced with transparency.
Space Removal: Removes spaces from image filenames and replaces them with underscores (_).
Filename Shortening: If a filename is too long, it truncates it to a maximum length (30 characters).
Cropping: The script crops any extra unused space around the image.
Resizing: Resizes the image to fit a 2:1 canvas (e.g., 400x200), ensuring the aspect ratio is preserved and the image is centered on the canvas.
Logs Skipped Images: If any image is skipped due to being unsupported, empty, or fully transparent, it logs the skipped filenames.
Dependencies:
Pillow (Python Imaging Library fork)
You can install it with:
pip install Pillow
How to Use:
Place your images in a folder (e.g., images).
Run the script, and it will automatically process and save the images in a folder (e.g., edited_images).
The processed images will be resized, centered, and saved in PNG format.
Note:
The script ensures that only valid images are processed and any issues with unsupported formats or transparency are logged in the console.
Here the script started:
from PIL import Image
import os
def ensure_transparency(image):
# Convert the image to RGBA (if it's not already in that mode)
if image.mode != 'RGBA':
image = image.convert('RGBA')
# If the image doesn't have a transparent background, add one
if image.getchannel('A').getextrema()[0] != 0:
# Replace the white or non-transparent background with transparency
image = image.convert('RGBA')
image_data = image.getdata()
new_data = []
for item in image_data:
# Change all white (also shades of whites) pixels to transparent
if item[0] in range(240, 256) and item[1] in range(240, 256) and item[2] in range(240, 256):
new_data.append((255, 255, 255, 0)) # Replace white with transparency
else:
new_data.append(item)
image.putdata(new_data)
return image
def process_image(input_path, output_path, target_width, target_height):
# Open the image
try:
image = Image.open(input_path)
except IOError:
print(f"Error opening {input_path}, skipping...")
return None
# Ensure the image is PNG and has transparency
image = ensure_transparency(image)
# Get the bounding box of the non-empty region (crops the unused space)
bbox = image.getbbox()
if bbox is None:
print(f"Image {input_path} has no content or is fully transparent, skipping...")
return None
# Crop the image using the bounding box
cropped_image = image.crop(bbox)
# Get the dimensions of the cropped image
img_width, img_height = cropped_image.size
aspect_ratio = target_width / target_height
# Calculate new dimensions to fit the image within the 2:1 aspect ratio
if img_width / img_height > aspect_ratio:
new_width = target_width
new_height = int(new_width * (img_height / img_width)) # Scale based on width
else:
new_height = target_height
new_width = int(new_height * (img_width / img_height)) # Scale based on height
# Resize the image to fit into the 2:1 canvas without cutting
resized_image = cropped_image.resize((new_width, new_height), Image.Resampling.LANCZOS)
# Create a new blank canvas with the target size
final_image = Image.new("RGBA", (target_width, target_height), (255, 255, 255, 0)) # Transparent background
# Calculate the position to paste the resized image in the center
x_offset = (target_width - new_width) // 2
y_offset = (target_height - new_height) // 2
# Paste the resized image onto the canvas
final_image.paste(resized_image, (x_offset, y_offset))
# Save the final image as PNG
final_image.save(output_path, 'PNG')
def shorten_filename(filename, max_length=30):
"""
Shortens the filename if it's too long, keeping the extension intact.
"""
name, ext = os.path.splitext(filename)
# If the filename is longer than the maximum length, truncate it
if len(name) > max_length:
name = name[:max_length]
return f"{name}{ext}"
def batch_process_images(input_directory, output_directory, target_width, target_height):
# Create the "edited_images" directory if it doesn't exist
if not os.path.exists(output_directory):
os.makedirs(output_directory)
# Track if any image is missed
missed_images = []
# Loop through all images in the input directory
for filename in os.listdir(input_directory):
if filename.lower().endswith(('.jpg', '.jpeg', '.png')): # Check image file types
image_path = os.path.join(input_directory, filename)
print(f"Processing: {filename}")
# Remove spaces and make the filename more descriptive
new_filename = filename.replace(" ", "_") # Replace spaces with underscores
new_filename = shorten_filename(new_filename, max_length=30) # Shorten the filename if necessary
# Define the output path for each processed image
output_path = os.path.join(output_directory, new_filename)
# Process the image (ensure transparency, crop, and resize)
result = process_image(image_path, output_path, target_width, target_height)
# If the result is None, the image was skipped
if result is None:
missed_images.append(filename)
else:
# If the image file doesn't have a valid extension, skip it and log the name
missed_images.append(filename)
# Print the missed images if any
if missed_images:
print("\nThe following images were skipped:")
for img in missed_images:
print(f" - {img}")
# Define the input and output directories
input_directory = './images' # Input folder where unedited images are stored
output_directory = './edited_images' # Output folder where edited images will be saved
# Call the function to process images
batch_process_images(input_directory, output_directory, 500, 250) # 2:1 ratio (400x200)
Top comments (0)