anchi-toolkit 1.0.0 → 1.2.1

package/dist/.cursor/skills/media-processing/references/troubleshooting.md

@@ -0,0 +1,109 @@
+# Media Processing Troubleshooting
+
+## FFmpeg Issues
+
+### Unknown Encoder Error
+```bash
+# Check available encoders
+ffmpeg -encoders | grep h264
+
+# Install codec libraries (Ubuntu/Debian)
+sudo apt-get install libx264-dev libx265-dev libvpx-dev
+```
+
+### Memory Errors
+```bash
+# Limit thread usage
+ffmpeg -threads 4 input.mp4 output.mp4
+
+# Process in segments for large files
+ffmpeg -i large.mp4 -ss 0 -t 600 segment1.mp4
+ffmpeg -i large.mp4 -ss 600 -t 600 segment2.mp4
+```
+
+### Slow Encoding
+```bash
+# Use faster preset (trades compression for speed)
+ffmpeg -i input.mp4 -c:v libx264 -preset ultrafast output.mp4
+
+# Use hardware acceleration
+ffmpeg -hwaccel cuda -i input.mp4 -c:v h264_nvenc output.mp4
+```
+
+## ImageMagick Issues
+
+### "Not Authorized" Error
+```bash
+# Edit policy file
+sudo nano /etc/ImageMagick-7/policy.xml
+
+# Change from:
+# <policy domain="coder" rights="none" pattern="PDF" />
+
+# To:
+# <policy domain="coder" rights="read|write" pattern="PDF" />
+```
+
+### Memory Limit Errors
+```bash
+# Increase memory limits
+magick -limit memory 2GB -limit map 4GB input.jpg output.jpg
+
+# Process in batches for large sets
+ls *.jpg | xargs -n 10 -P 4 mogrify -resize 800x
+```
+
+### Slow Batch Processing
+```bash
+# Use parallel processing with GNU Parallel
+ls *.jpg | parallel -j 4 magick {} -resize 800x resized-{}
+
+# Or use mogrify for in-place edits (faster)
+mogrify -resize 800x *.jpg
+```
+
+## RMBG Issues
+
+### Model Download Failures
+```bash
+# Check network connectivity
+curl https://unpkg.com/@rmbg/model-modnet/modnet-256.onnx
+
+# Use custom cache directory
+RMBG_CACHE_DIR=/tmp/rmbg-cache rmbg input.jpg
+
+# Clear cache and retry
+rm -rf /tmp/rmbg-cache
+rmbg input.jpg
+```
+
+### Out of Memory
+```bash
+# Use smaller model
+rmbg input.jpg -m u2netp -o output.png
+
+# Reduce resolution
+rmbg input.jpg -r 1024 -o output.png
+```
+
+### Slow Processing
+```bash
+# Use fastest model
+rmbg input.jpg -m u2netp -o output.png
+
+# Process smaller resolution
+rmbg input.jpg -r 1024 -o output.png
+```
+
+## Performance Tips
+
+1. **Use CRF for quality control** - Better than bitrate for video encoding
+2. **Copy streams when possible** - Avoid re-encoding with `-c copy`
+3. **Hardware acceleration** - GPU encoding 5-10x faster than CPU
+4. **Appropriate presets** - Balance speed vs compression (`fast`, `medium`, `slow`)
+5. **Batch with mogrify** - In-place image processing faster than individual commands
+6. **Strip metadata** - Reduce file size with `-strip` flag
+7. **Progressive JPEG** - Better web loading with `-interlace Plane`
+8. **Test on samples** - Verify settings before processing large batches
+9. **Parallel processing** - Use GNU Parallel for multiple files
+10. **Limit memory** - Prevent crashes on large batches with `-limit` flags

package/dist/.cursor/skills/media-processing/scripts/batch-remove-background.sh

@@ -0,0 +1,124 @@
+#!/bin/bash
+# Batch background removal script using RMBG CLI
+# Usage: ./batch-remove-background.sh <input_dir> [output_dir] [model] [resolution]
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Default values
+INPUT_DIR=""
+OUTPUT_DIR=""
+MODEL="modnet"
+MAX_RESOLUTION="2048"
+
+# Parse arguments
+INPUT_DIR="$1"
+if [ -n "$2" ]; then
+    OUTPUT_DIR="$2"
+fi
+if [ -n "$3" ]; then
+    MODEL="$3"
+fi
+if [ -n "$4" ]; then
+    MAX_RESOLUTION="$4"
+fi
+
+# Validate input directory
+if [ -z "$INPUT_DIR" ]; then
+    echo -e "${RED}Error: Input directory is required${NC}"
+    echo ""
+    echo "Usage: $0 <input_dir> [output_dir] [model] [resolution]"
+    echo ""
+    echo "Arguments:"
+    echo "  input_dir   Input directory with images (required)"
+    echo "  output_dir  Output directory (default: input_dir/no-bg)"
+    echo "  model       Model name: u2netp, modnet, briaai, isnet-anime, silueta, u2net-cloth (default: modnet)"
+    echo "  resolution  Max resolution in pixels (default: 2048)"
+    echo ""
+    echo "Examples:"
+    echo "  $0 ./photos"
+    echo "  $0 ./photos ./output"
+    echo "  $0 ./photos ./output briaai"
+    echo "  $0 ./photos ./output briaai 4096"
+    exit 1
+fi
+
+if [ ! -d "$INPUT_DIR" ]; then
+    echo -e "${RED}Error: Input directory '$INPUT_DIR' not found${NC}"
+    exit 1
+fi
+
+# Set default output directory
+if [ -z "$OUTPUT_DIR" ]; then
+    OUTPUT_DIR="$INPUT_DIR/no-bg"
+fi
+
+# Create output directory if it doesn't exist
+mkdir -p "$OUTPUT_DIR"
+
+# Check if rmbg-cli is installed
+if ! command -v rmbg &> /dev/null; then
+    echo -e "${YELLOW}Warning: rmbg-cli not found${NC}"
+    echo "Installing rmbg-cli globally..."
+    npm install -g rmbg-cli
+    echo -e "${GREEN}✓ rmbg-cli installed${NC}"
+fi
+
+# Find all image files
+IMAGE_FILES=$(find "$INPUT_DIR" -maxdepth 1 -type f \( -iname "*.jpg" -o -iname "*.jpeg" -o -iname "*.png" -o -iname "*.webp" \))
+TOTAL_FILES=$(echo "$IMAGE_FILES" | grep -v '^$' | wc -l | tr -d ' ')
+
+if [ "$TOTAL_FILES" -eq 0 ]; then
+    echo -e "${YELLOW}Warning: No image files found in '$INPUT_DIR'${NC}"
+    exit 0
+fi
+
+# Display configuration
+echo -e "${GREEN}Batch Background Removal Configuration:${NC}"
+echo "  Input Dir:  $INPUT_DIR"
+echo "  Output Dir: $OUTPUT_DIR"
+echo "  Model:      $MODEL"
+echo "  Resolution: $MAX_RESOLUTION"
+echo "  Total Files: $TOTAL_FILES"
+echo ""
+
+# Process each image
+SUCCESS_COUNT=0
+FAIL_COUNT=0
+CURRENT=0
+
+while IFS= read -r file; do
+    [ -z "$file" ] && continue
+
+    CURRENT=$((CURRENT + 1))
+    BASENAME=$(basename "$file")
+    OUTPUT_FILE="$OUTPUT_DIR/${BASENAME%.*}.png"
+
+    echo -e "${BLUE}[$CURRENT/$TOTAL_FILES]${NC} Processing: $BASENAME"
+
+    if rmbg "$file" -m "$MODEL" -o "$OUTPUT_FILE" -r "$MAX_RESOLUTION" 2>/dev/null; then
+        SUCCESS_COUNT=$((SUCCESS_COUNT + 1))
+        echo -e "  ${GREEN}✓ Success${NC}"
+    else
+        FAIL_COUNT=$((FAIL_COUNT + 1))
+        echo -e "  ${RED}✗ Failed${NC}"
+    fi
+done <<< "$IMAGE_FILES"
+
+# Display summary
+echo ""
+echo -e "${GREEN}Batch Processing Complete${NC}"
+echo "  Total:   $TOTAL_FILES files"
+echo "  Success: $SUCCESS_COUNT files"
+echo "  Failed:  $FAIL_COUNT files"
+echo "  Output:  $OUTPUT_DIR"
+
+if [ "$FAIL_COUNT" -gt 0 ]; then
+    exit 1
+fi

package/dist/.cursor/skills/media-processing/scripts/batch_resize.py

@@ -0,0 +1,342 @@
+#!/usr/bin/env python3
+"""
+Batch image resizing with multiple strategies.
+
+Supports aspect ratio maintenance, smart cropping, thumbnail generation,
+watermarks, format conversion, and parallel processing.
+"""
+
+import argparse
+import subprocess
+import sys
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+
+class ImageResizer:
+    """Handle image resizing operations using ImageMagick."""
+
+    def __init__(self, verbose: bool = False, dry_run: bool = False):
+        self.verbose = verbose
+        self.dry_run = dry_run
+
+    def check_imagemagick(self) -> bool:
+        """Check if ImageMagick is available."""
+        try:
+            subprocess.run(
+                ['magick', '-version'],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                check=True
+            )
+            return True
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return False
+
+    def build_resize_command(
+        self,
+        input_path: Path,
+        output_path: Path,
+        width: Optional[int],
+        height: Optional[int],
+        strategy: str,
+        quality: int,
+        watermark: Optional[Path] = None
+    ) -> List[str]:
+        """Build ImageMagick resize command based on strategy."""
+        cmd = ['magick', str(input_path)]
+
+        # Apply resize strategy
+        if strategy == 'fit':
+            # Fit within dimensions, maintain aspect ratio
+            geometry = f"{width or ''}x{height or ''}"
+            cmd.extend(['-resize', geometry])
+
+        elif strategy == 'fill':
+            # Fill dimensions, crop excess
+            if not width or not height:
+                raise ValueError("Both width and height required for 'fill' strategy")
+            cmd.extend([
+                '-resize', f'{width}x{height}^',
+                '-gravity', 'center',
+                '-extent', f'{width}x{height}'
+            ])
+
+        elif strategy == 'cover':
+            # Cover dimensions, may exceed
+            if not width or not height:
+                raise ValueError("Both width and height required for 'cover' strategy")
+            cmd.extend(['-resize', f'{width}x{height}^'])
+
+        elif strategy == 'exact':
+            # Force exact dimensions, ignore aspect ratio
+            if not width or not height:
+                raise ValueError("Both width and height required for 'exact' strategy")
+            cmd.extend(['-resize', f'{width}x{height}!'])
+
+        elif strategy == 'thumbnail':
+            # Create square thumbnail
+            size = width or height or 200
+            cmd.extend([
+                '-resize', f'{size}x{size}^',
+                '-gravity', 'center',
+                '-extent', f'{size}x{size}'
+            ])
+
+        # Add watermark if specified
+        if watermark:
+            cmd.extend([
+                str(watermark),
+                '-gravity', 'southeast',
+                '-geometry', '+10+10',
+                '-composite'
+            ])
+
+        # Output settings
+        cmd.extend([
+            '-quality', str(quality),
+            '-strip',
+            str(output_path)
+        ])
+
+        return cmd
+
+    def resize_image(
+        self,
+        input_path: Path,
+        output_path: Path,
+        width: Optional[int],
+        height: Optional[int],
+        strategy: str = 'fit',
+        quality: int = 85,
+        watermark: Optional[Path] = None
+    ) -> bool:
+        """Resize a single image."""
+        try:
+            # Ensure output directory exists
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+
+            cmd = self.build_resize_command(
+                input_path, output_path, width, height,
+                strategy, quality, watermark
+            )
+
+            if self.verbose or self.dry_run:
+                print(f"Command: {' '.join(cmd)}")
+
+            if self.dry_run:
+                return True
+
+            subprocess.run(
+                cmd,
+                stdout=subprocess.PIPE if not self.verbose else None,
+                stderr=subprocess.PIPE if not self.verbose else None,
+                check=True
+            )
+            return True
+
+        except subprocess.CalledProcessError as e:
+            print(f"Error resizing {input_path}: {e}", file=sys.stderr)
+            if not self.verbose and e.stderr:
+                print(e.stderr.decode(), file=sys.stderr)
+            return False
+        except Exception as e:
+            print(f"Error processing {input_path}: {e}", file=sys.stderr)
+            return False
+
+    def batch_resize(
+        self,
+        input_paths: List[Path],
+        output_dir: Path,
+        width: Optional[int],
+        height: Optional[int],
+        strategy: str = 'fit',
+        quality: int = 85,
+        format_ext: Optional[str] = None,
+        watermark: Optional[Path] = None,
+        parallel: int = 1
+    ) -> Tuple[int, int]:
+        """Resize multiple images."""
+        success_count = 0
+        fail_count = 0
+
+        def process_image(input_path: Path) -> Tuple[Path, bool]:
+            """Process single image for parallel execution."""
+            if not input_path.exists() or not input_path.is_file():
+                return input_path, False
+
+            # Determine output path
+            output_name = input_path.stem
+            if format_ext:
+                output_path = output_dir / f"{output_name}.{format_ext.lstrip('.')}"
+            else:
+                output_path = output_dir / input_path.name
+
+            if not self.dry_run:
+                print(f"Processing {input_path.name} -> {output_path.name}")
+
+            success = self.resize_image(
+                input_path, output_path, width, height,
+                strategy, quality, watermark
+            )
+
+            return input_path, success
+
+        # Process images
+        if parallel > 1:
+            with ThreadPoolExecutor(max_workers=parallel) as executor:
+                futures = [executor.submit(process_image, path) for path in input_paths]
+
+                for future in as_completed(futures):
+                    _, success = future.result()
+                    if success:
+                        success_count += 1
+                    else:
+                        fail_count += 1
+        else:
+            for input_path in input_paths:
+                _, success = process_image(input_path)
+                if success:
+                    success_count += 1
+                else:
+                    fail_count += 1
+
+        return success_count, fail_count
+
+
+def collect_images(paths: List[Path], recursive: bool = False) -> List[Path]:
+    """Collect image files from paths."""
+    image_exts = {'.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp', '.tiff', '.tif'}
+    images = []
+
+    for path in paths:
+        if path.is_file() and path.suffix.lower() in image_exts:
+            images.append(path)
+        elif path.is_dir():
+            pattern = '**/*' if recursive else '*'
+            for img_path in path.glob(pattern):
+                if img_path.is_file() and img_path.suffix.lower() in image_exts:
+                    images.append(img_path)
+
+    return images
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description='Batch image resizing with multiple strategies.'
+    )
+    parser.add_argument(
+        'inputs',
+        nargs='+',
+        type=Path,
+        help='Input image(s) or directory'
+    )
+    parser.add_argument(
+        '-o', '--output',
+        type=Path,
+        required=True,
+        help='Output directory'
+    )
+    parser.add_argument(
+        '-w', '--width',
+        type=int,
+        help='Target width in pixels'
+    )
+    parser.add_argument(
+        '-h', '--height',
+        type=int,
+        dest='img_height',
+        help='Target height in pixels'
+    )
+    parser.add_argument(
+        '-s', '--strategy',
+        choices=['fit', 'fill', 'cover', 'exact', 'thumbnail'],
+        default='fit',
+        help='Resize strategy (default: fit)'
+    )
+    parser.add_argument(
+        '-q', '--quality',
+        type=int,
+        default=85,
+        help='Output quality 0-100 (default: 85)'
+    )
+    parser.add_argument(
+        '-f', '--format',
+        help='Output format (e.g., jpg, png, webp)'
+    )
+    parser.add_argument(
+        '-wm', '--watermark',
+        type=Path,
+        help='Watermark image to overlay'
+    )
+    parser.add_argument(
+        '-p', '--parallel',
+        type=int,
+        default=1,
+        help='Number of parallel processes (default: 1)'
+    )
+    parser.add_argument(
+        '-r', '--recursive',
+        action='store_true',
+        help='Process directories recursively'
+    )
+    parser.add_argument(
+        '-n', '--dry-run',
+        action='store_true',
+        help='Show commands without executing'
+    )
+    parser.add_argument(
+        '-v', '--verbose',
+        action='store_true',
+        help='Verbose output'
+    )
+
+    args = parser.parse_args()
+
+    # Validate dimensions
+    if not args.width and not args.img_height:
+        print("Error: At least one of --width or --height required", file=sys.stderr)
+        sys.exit(1)
+
+    # Initialize resizer
+    resizer = ImageResizer(verbose=args.verbose, dry_run=args.dry_run)
+
+    # Check dependencies
+    if not resizer.check_imagemagick():
+        print("Error: ImageMagick not found", file=sys.stderr)
+        sys.exit(1)
+
+    # Collect input images
+    images = collect_images(args.inputs, args.recursive)
+
+    if not images:
+        print("Error: No images found", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"Found {len(images)} image(s) to process")
+
+    # Create output directory
+    if not args.dry_run:
+        args.output.mkdir(parents=True, exist_ok=True)
+
+    # Process images
+    success, fail = resizer.batch_resize(
+        images,
+        args.output,
+        args.width,
+        args.img_height,
+        args.strategy,
+        args.quality,
+        args.format,
+        args.watermark,
+        args.parallel
+    )
+
+    print(f"\nResults: {success} succeeded, {fail} failed")
+    sys.exit(0 if fail == 0 else 1)
+
+
+if __name__ == '__main__':
+    main()