Create optimize_image.py

optimize_image.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+import os
+import sys
+from PIL import Image
+import glob
+from pathlib import Path
+import shutil
+
+# Configuration
+TARGET_SIZE = 100 * 1024  # 100KB in bytes
+TARGET_FOLDERS = ["alt", "thumbnail"]
+QUALITY_STEP = 5  # How much to reduce quality on each iteration
+MIN_QUALITY = 20  # Don't go below this quality
+INITIAL_QUALITY = 85  # Starting quality
+RESIZE_FACTOR = 0.9  # Resize factor when quality reduction alone isn't enough
+
+def get_file_size(file_path):
+    """Get file size in bytes"""
+    return os.path.getsize(file_path)
+
+def optimize_image(image_path, target_size=TARGET_SIZE):
+    """
+    Optimize an image to be under the target size
+    Returns: (success, original_size, new_size)
+    """
+    # Check if file exists
+    if not os.path.exists(image_path):
+        print(f"File not found: {image_path}")
+        return False, 0, 0
+    
+    # Get original size
+    original_size = get_file_size(image_path)
+    
+    # If already under target size, no need to optimize
+    if original_size <= target_size:
+        print(f"Already optimized: {image_path} ({original_size} bytes)")
+        return True, original_size, original_size
+    
+    # Create a backup copy
+    backup_path = f"{image_path}.backup"
+    try:
+        shutil.copy2(image_path, backup_path)
+    except Exception as e:
+        print(f"Failed to create backup of {image_path}: {str(e)}")
+        return False, original_size, 0
+    
+    try:
+        # Open the image
+        img = Image.open(image_path)
+        
+        # Get format and extension
+        img_format = img.format
+        extension = os.path.splitext(image_path)[1].lower()
+        
+        # Convert PNG to JPG if it's not transparent
+        if img_format == "PNG" and extension == ".png":
+            if not img.mode == 'RGBA' or not has_transparency(img):
+                img = img.convert('RGB')
+                img_format = "JPEG"
+                new_path = os.path.splitext(image_path)[0] + ".jpg"
+            else:
+                new_path = image_path
+        else:
+            new_path = image_path
+            if img.mode == 'RGBA':
+                # JPG doesn't support transparency, convert to RGB
+                if img_format == "JPEG" or extension in [".jpg", ".jpeg"]:
+                    img = img.convert('RGB')
+                    
+        # Start with original size and initial quality
+        quality = INITIAL_QUALITY
+        width, height = img.size
+        
+        # Try to optimize by reducing quality first
+        while quality >= MIN_QUALITY:
+            if img_format == "JPEG" or img_format == "PNG":
+                img.save(new_path, format=img_format, quality=quality, optimize=True)
+            else:
+                # For other formats, just save with PIL's default settings
+                img.save(new_path, format=img_format)
+            
+            # Check new size
+            new_size = get_file_size(new_path)
+            
+            if new_size <= target_size:
+                # If we changed from PNG to JPG, remove the original
+                if new_path != image_path:
+                    os.remove(image_path)
+                
+                # Remove the backup
+                os.remove(backup_path)
+                
+                # Log the result
+                size_reduction = original_size - new_size
+                percentage = (size_reduction / original_size) * 100
+                print(f"Optimized: {image_path} - {original_size} → {new_size} bytes ({percentage:.1f}% reduction)")
+                return True, original_size, new_size
+            
+            # Reduce quality for next iteration
+            quality -= QUALITY_STEP
+        
+        # If reducing quality didn't work, try resizing the image
+        scale_factor = RESIZE_FACTOR
+        quality = INITIAL_QUALITY
+        
+        while scale_factor > 0.1:  # Don't shrink image too much
+            # Resize the image
+            new_width = int(width * scale_factor)
+            new_height = int(height * scale_factor)
+            resized_img = img.resize((new_width, new_height), Image.LANCZOS)
+            
+            # Try different qualities with this size
+            current_quality = quality
+            while current_quality >= MIN_QUALITY:
+                if img_format == "JPEG" or img_format == "PNG":
+                    resized_img.save(new_path, format=img_format, quality=current_quality, optimize=True)
+                else:
+                    resized_img.save(new_path, format=img_format)
+                
+                # Check new size
+                new_size = get_file_size(new_path)
+                
+                if new_size <= target_size:
+                    # If we changed from PNG to JPG, remove the original
+                    if new_path != image_path:
+                        os.remove(image_path)
+                    
+                    # Remove the backup
+                    os.remove(backup_path)
+                    
+                    # Log the result
+                    size_reduction = original_size - new_size
+                    percentage = (size_reduction / original_size) * 100
+                    print(f"Optimized: {image_path} - {original_size} → {new_size} bytes ({percentage:.1f}% reduction)")
+                    print(f"  - Resized from {width}x{height} to {new_width}x{new_height}, quality: {current_quality}")
+                    return True, original_size, new_size
+                
+                # Reduce quality for next iteration
+                current_quality -= QUALITY_STEP
+            
+            # Reduce size for next iteration
+            scale_factor *= RESIZE_FACTOR
+        
+        # If we couldn't optimize the image, restore from backup
+        print(f"Failed to optimize {image_path} to under {TARGET_SIZE/1024}KB")
+        if os.path.exists(backup_path):
+            shutil.move(backup_path, image_path)
+        return False, original_size, 0
+        
+    except Exception as e:
+        print(f"Error optimizing {image_path}: {str(e)}")
+        # Restore from backup
+        if os.path.exists(backup_path):
+            shutil.move(backup_path, image_path)
+        return False, original_size, 0
+
+def has_transparency(img):
+    """Check if image has transparency"""
+    if img.mode == 'RGBA':
+        extrema = img.getextrema()
+        if len(extrema) >= 4:  # Check alpha channel
+            if extrema[3][0] < 255:  # Check if minimum alpha value is less than 255
+                return True
+    return False
+
+def find_images(root_dir, target_folders=TARGET_FOLDERS):
+    """
+    Find all images in target folders
+    Returns: list of image paths
+    """
+    image_paths = []
+    
+    # Walk through all directories
+    for folder in target_folders:
+        # Use glob to find alt and thumbnail folders
+        folder_pattern = os.path.join(root_dir, "**", folder, "*")
+        for image_path in glob.glob(folder_pattern, recursive=True):
+            # Check if it's a file and an image
+            if os.path.isfile(image_path) and is_image_file(image_path):
+                image_paths.append(image_path)
+    
+    return image_paths
+
+def is_image_file(path):
+    """Check if file is an image based on extension"""
+    ext = os.path.splitext(path)[1].lower()
+    return ext in ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp']
+
+def main():
+    # Get the root directory
+    if len(sys.argv) > 1:
+        root_dir = sys.argv[1]
+    else:
+        root_dir = os.getcwd()
+    
+    print(f"Finding images in {root_dir}...")
+    
+    # Find all images
+    image_paths = find_images(root_dir)
+    
+    if not image_paths:
+        print("No images found in target folders.")
+        return
+    
+    print(f"Found {len(image_paths)} images. Starting optimization...")
+    
+    # Keep track of statistics
+    total_processed = 0
+    successful = 0
+    total_original_size = 0
+    total_new_size = 0
+    
+    # Process each image
+    for image_path in image_paths:
+        success, original_size, new_size = optimize_image(image_path)
+        total_processed += 1
+        if success and new_size < original_size:
+            successful += 1
+            total_original_size += original_size
+            total_new_size += new_size
+    
+    # Print summary
+    print("\nOptimization Summary:")
+    print(f"Processed {total_processed} images")
+    print(f"Successfully optimized {successful} images")
+    
+    if successful > 0:
+        total_saved = total_original_size - total_new_size
+        percentage = (total_saved / total_original_size) * 100
+        print(f"Total size reduction: {total_saved / 1024:.2f}KB ({percentage:.1f}%)")
+        print(f"Average size before: {total_original_size / successful / 1024:.2f}KB")
+        print(f"Average size after: {total_new_size / successful / 1024:.2f}KB")
+
+if __name__ == "__main__":
+    main()