Update converters/image_converter.py

converters/image_converter.py

@@ -1,105 +1,279 @@
-from PIL import Image
+from PIL import (
+    Image,
+    ImageEnhance,
+    ImageFilter,
+    ImageOps
+)
+
 from pathlib import Path
 from typing import Callable, Dict, Any
+
 import traceback
 import os
 
 
 class ImageConverter:
+
+    SUPPORTED_FORMATS = {
+        ".png",
+        ".jpg",
+        ".jpeg",
+        ".webp",
+        ".bmp",
+        ".tiff"
+    }
+
     def __init__(self):
-        pass
 
-    def convert(self, input_path: str, output_path: str,
-                options: Dict[str, Any], progress_callback: Callable = None) -> bool:
-        """Convert image files"""
+        # Prevent PIL decompression bomb crash
+        Image.MAX_IMAGE_PIXELS = None
+
+    def convert(
+        self,
+        input_path: str,
+        output_path: str,
+        options: Dict[str, Any] | None = None,
+        progress_callback: Callable = None
+    ) -> bool:
+
+        options = options or {}
+
         try:
-            # Update progress safely
-            self._update_progress(progress_callback, 10)
 
-            # Check if input file exists
+            self._update_progress(
+                progress_callback,
+                10
+            )
+
+            # Validate input
             if not os.path.exists(input_path):
-                print(f"Input file not found: {input_path}")
-                return False
 
-            # Open image
+                raise FileNotFoundError(
+                    input_path
+                )
+
+            input_ext = Path(input_path).suffix.lower()
+            output_ext = Path(output_path).suffix.lower()
+
+            # Validate output format
+            if output_ext not in self.SUPPORTED_FORMATS:
+
+                raise ValueError(
+                    f"Unsupported format: {output_ext}"
+                )
+
+            # Open image safely
             img = Image.open(input_path)
 
-            self._update_progress(progress_callback, 30)
+            # Fix EXIF rotation
+            img = ImageOps.exif_transpose(img)
+
+            self._update_progress(
+                progress_callback,
+                25
+            )
+
+            # Convert palette images safely
+            if img.mode == "P":
+                img = img.convert("RGBA")
+
+            # Optional resize
+            max_size = options.get("max_size")
+
+            if max_size:
+
+                img.thumbnail(
+                    (max_size, max_size)
+                )
+
+            self._update_progress(
+                progress_callback,
+                40
+            )
+
+            # AI enhancement
+            if options.get(
+                "ai_enhancement",
+                False
+            ):
 
-            # Apply AI enhancement if requested
-            if options.get("ai_enhancement", False):
                 img = self.enhance_image(img)
 
-            self._update_progress(progress_callback, 50)
+            self._update_progress(
+                progress_callback,
+                60
+            )
 
-            # Get quality settings
-            quality_settings = options.get("quality_settings", {})
-            quality = quality_settings.get("image", 85)
+            # Quality
+            quality_settings = options.get(
+                "quality_settings",
+                {}
+            )
 
-            # Create output directory if needed
-            Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+            quality = int(
+                quality_settings.get(
+                    "image",
+                    85
+                )
+            )
 
-            # Convert and save based on output format
-            output_ext = Path(output_path).suffix.lower()
+            # Create output folder
+            Path(output_path).parent.mkdir(
+                parents=True,
+                exist_ok=True
+            )
+
+            # Format handling
+            if output_ext in [".jpg", ".jpeg"]:
+
+                # JPEG does not support transparency
+                if img.mode in ("RGBA", "LA"):
+
+                    background = Image.new(
+                        "RGB",
+                        img.size,
+                        (255, 255, 255)
+                    )
+
+                    background.paste(
+                        img,
+                        mask=img.split()[-1]
+                    )
+
+                    img = background
+
+                else:
+
+                    img = img.convert("RGB")
+
+                img.save(
+                    output_path,
+                    "JPEG",
+                    quality=quality,
+                    optimize=True
+                )
 
-            self._update_progress(progress_callback, 70)
+            elif output_ext == ".png":
 
-            # Handle different formats
-            if output_ext in ['.jpg', '.jpeg']:
-                # Convert RGBA to RGB for JPEG
-                if img.mode in ('RGBA', 'P'):
-                    img = img.convert('RGB')
-                img.save(output_path, 'JPEG', quality=quality, optimize=True)
+                compress_level = 9
 
-            elif output_ext == '.png':
-                # PNG uses compression level (0-9)
-                compression = 6 if quality < 90 else 3
-                img.save(output_path, 'PNG', compress_level=compression, optimize=True)
+                if quality >= 90:
+                    compress_level = 2
 
-            elif output_ext == '.webp':
-                img.save(output_path, 'WEBP', quality=quality, method=6)
+                elif quality >= 75:
+                    compress_level = 5
 
-            elif output_ext == '.bmp':
-                img.save(output_path, 'BMP')
+                img.save(
+                    output_path,
+                    "PNG",
+                    optimize=True,
+                    compress_level=compress_level
+                )
 
-            elif output_ext == '.tiff':
-                img.save(output_path, 'TIFF', compression='tiff_lzw')
+            elif output_ext == ".webp":
+
+                img.save(
+                    output_path,
+                    "WEBP",
+                    quality=quality,
+                    method=6
+                )
+
+            elif output_ext == ".bmp":
+
+                if img.mode == "RGBA":
+                    img = img.convert("RGB")
+
+                img.save(
+                    output_path,
+                    "BMP"
+                )
+
+            elif output_ext == ".tiff":
+
+                img.save(
+                    output_path,
+                    "TIFF",
+                    compression="tiff_lzw"
+                )
 
             else:
+
                 img.save(output_path)
 
-            self._update_progress(progress_callback, 100)
+            self._update_progress(
+                progress_callback,
+                100
+            )
+
+            print(
+                f"✓ Converted: "
+                f"{os.path.basename(input_path)} "
+                f"→ {output_ext}"
+            )
 
-            print(f"✓ Successfully converted: {os.path.basename(input_path)} → {output_ext}")
             return True
 
         except Exception as e:
-            print(f"Image conversion error for {input_path}: {str(e)}")
+
+            print(
+                f"Image conversion error: {e}"
+            )
+
             traceback.print_exc()
+
             return False
 
-    def _update_progress(self, callback, value):
-        """Safely update progress"""
-        if callback is not None:
-            try:
+    def _update_progress(
+        self,
+        callback,
+        value
+    ):
+
+        try:
+
+            if callback:
                 callback(value)
-            except Exception as e:
-                # If callback fails (e.g., Qt signal issue), just continue
-                pass
 
-    def enhance_image(self, img):
-        """Basic image enhancement"""
+        except Exception as e:
+
+            print(
+                f"Progress callback error: {e}"
+            )
+
+    def enhance_image(
+        self,
+        img
+    ):
+
         try:
-            from PIL import ImageEnhance, ImageFilter
 
-            # Enhance contrast slightly
+            # Contrast
             enhancer = ImageEnhance.Contrast(img)
-            img = enhancer.enhance(1.1)
 
-            # Enhance sharpness
+            img = enhancer.enhance(1.08)
+
+            # Sharpness
             enhancer = ImageEnhance.Sharpness(img)
-            img = enhancer.enhance(1.05)
+
+            img = enhancer.enhance(1.1)
+
+            # Slight color boost
+            enhancer = ImageEnhance.Color(img)
+
+            img = enhancer.enhance(1.03)
+
+            # Optional smooth sharpen
+            img = img.filter(
+                ImageFilter.SHARPEN
+            )
 
             return img
-        except:
+
+        except Exception as e:
+
+            print(
+                f"Enhancement error: {e}"
+            )
+
             return img