Refactor image processing in img_clean_sketch.py to enhance functionality

This commit modifies the img_clean_sketch.py script to improve image processing capabilities. Key changes include:
- Updated the process_image function to create a new data array for modifications, ensuring the original data remains unchanged.
- Enhanced white and grayscale pixel detection logic for better accuracy.
- Refactored process_directory to process multiple files and directories, improving flexibility in handling input paths.
- Updated the main function to accept multiple paths as arguments.

These improvements streamline the image processing workflow and enhance the script's usability.

utils/img_clean_sketch.py

@@ -1,4 +1,4 @@
- #!/usr/bin/env python
+#!/usr/bin/env python
 # -*- coding: utf-8 -*-
 #
 # 画像の白い背景を透明にし、グレースケールを黒に変換する
@@ -10,6 +10,7 @@ from PIL import Image
 import argparse
 from pathlib import Path
 import os
+from typing import List, Union
 
 def process_image(image_path: Path, tolerance: int = 10, gray_tolerance: int = 5) -> None:
     """
@@ -25,69 +26,105 @@ def process_image(image_path: Path, tolerance: int = 10, gray_tolerance: int = 5
         img = Image.open(image_path).convert("RGBA")
         data = np.array(img)
         
-        # Create alpha mask based on white detection
+        # Get alpha channel
+        alpha = data[:, :, 3]
+        
+        # Create masks for processing
         r, g, b = data[:, :, 0], data[:, :, 1], data[:, :, 2]
-        white_mask = (abs(r - 255) <= tolerance) & \
-                    (abs(g - 255) <= tolerance) & \
-                    (abs(b - 255) <= tolerance)
         
-        # Detect grayscale pixels (where R ≈ G ≈ B)
-        gray_mask = (abs(r - g) <= gray_tolerance) & \
-                   (abs(g - b) <= gray_tolerance) & \
-                   (abs(r - b) <= gray_tolerance) & \
-                   ~white_mask  # Exclude white pixels
+        # Calculate color intensity (average of RGB)
+        color_intensity = (r + g + b) / 3.0
+        
+        # Detect white pixels (only in areas that aren't already transparent)
+        white_mask = ((color_intensity >= 250) &  # Very bright pixels
+                     (abs(r - g) <= tolerance) &   # Similar RGB values
+                     (abs(g - b) <= tolerance) & 
+                     (abs(r - b) <= tolerance) & 
+                     (alpha > 0))                  # Only non-transparent pixels
+        
+        # Detect grayscale pixels (excluding white and transparent)
+        gray_mask = ((abs(r - g) <= gray_tolerance) & 
+                    (abs(g - b) <= gray_tolerance) & 
+                    (abs(r - b) <= gray_tolerance) & 
+                    (color_intensity < 250) &      # Not too bright
+                    (alpha > 0) &                  # Not transparent
+                    ~white_mask)                   # Not white
+        
+        # Debug info
+        print(f"Original alpha range: {alpha.min()}-{alpha.max()}")
+        print(f"White pixels detected: {white_mask.sum()}")
+        print(f"Gray pixels detected: {gray_mask.sum()}")
         
-        # Set alpha channel to 0 where white is detected
-        data[:, :, 3] = np.where(white_mask, 0, data[:, :, 3])
+        # Create new data array to avoid modifying original
+        new_data = data.copy()
         
-        # Convert grayscale pixels to black
-        data[gray_mask, 0:3] = 0  # Set RGB to 0 (black)
+        # Make white pixels transparent
+        new_data[white_mask, 3] = 0
+        
+        # Convert grayscale to black while preserving alpha
+        new_data[gray_mask, 0:3] = 0
+        
+        # Debug info after modifications
+        print(f"Final alpha range: {new_data[:,:,3].min()}-{new_data[:,:,3].max()}")
         
         # Create output path with suffix
         output_path = image_path.parent / f"{image_path.stem}-processed.png"
         
         # Save the modified image
-        Image.fromarray(data).save(output_path, "PNG")
+        Image.fromarray(new_data).save(output_path, "PNG")
         print(f"Processed image saved as {output_path}")
         
     except Exception as e:
         print(f"Error processing {image_path}: {e}")
 
-def process_directory(directory: Path, tolerance: int = 10, gray_tolerance: int = 5, recursive: bool = False) -> None:
+def process_paths(paths: List[Union[str, Path]], tolerance: int = 10, gray_tolerance: int = 5, recursive: bool = False) -> None:
     """
-    Process all images in a directory.
+    Process multiple files and/or directories.
     
     Args:
-        directory (Path): Directory containing image files
-        tolerance (int): Color tolerance for white detection
-        gray_tolerance (int): Tolerance for grayscale detection
-        recursive (bool): Whether to process subdirectories
+        paths: List of file and directory paths to process
+        tolerance: Color tolerance for white detection
+        gray_tolerance: Tolerance for grayscale detection
+        recursive: Whether to process subdirectories recursively
     """
-    # Supported image extensions (from imgproc_utils.py pattern)
+    # Supported image extensions
     extensions = {".png", ".jpg", ".jpeg", ".webp", ".bmp"}
     
-    # Get file list based on recursive flag
-    if recursive:
-        files = [f for ext in extensions for f in directory.rglob(f"*{ext}")]
-    else:
-        files = [f for ext in extensions for f in directory.glob(f"*{ext}")]
-    
-    if not files:
-        print(f"No supported image files found in {directory}")
-        return
-    
-    for file_path in files:
-        process_image(file_path, tolerance, gray_tolerance)
+    for path in paths:
+        path = Path(path)
+        
+        if not path.exists():
+            print(f"Error: Path does not exist: {path}")
+            continue
+            
+        if path.is_file():
+            if path.suffix.lower() in extensions:
+                process_image(path, tolerance, gray_tolerance)
+            else:
+                print(f"Skipping unsupported file: {path}")
+        
+        elif path.is_dir():
+            # Process directory
+            if recursive:
+                files = [f for ext in extensions for f in path.rglob(f"*{ext}")]
+            else:
+                files = [f for ext in extensions for f in path.glob(f"*{ext}")]
+            
+            if not files:
+                print(f"No supported image files found in {path}")
+                continue
+                
+            for file_path in files:
+                process_image(file_path, tolerance, gray_tolerance)
 
 def main():
     parser = argparse.ArgumentParser(
         description="Remove white background and convert grayscale colors to black."
     )
     parser.add_argument(
-        "-d", "--directory",
-        type=str,
-        default=".",
-        help="Directory containing the image files (default: current directory)"
+        "paths",
+        nargs="+",
+        help="One or more image files or directories to process"
     )
     parser.add_argument(
         "-t", "--tolerance",
@@ -108,17 +145,7 @@ def main():
     )
     args = parser.parse_args()
     
-    target_directory = Path(args.directory)
-    if not target_directory.exists():
-        print(f"Error: Directory {target_directory} does not exist.")
-        return 1
-    
-    process_directory(
-        target_directory, 
-        args.tolerance, 
-        args.gray_tolerance,
-        args.recursive
-    )
+    process_paths(args.paths, args.tolerance, args.gray_tolerance, args.recursive)
     return 0
 
 if __name__ == "__main__":