codewave-openclaw-installer 1.0.2 → 2.1.0

package/skills/ppt-master/scripts/finalize_svg.py

@@ -0,0 +1,302 @@
+#!/usr/bin/env python3
+"""
+PPT Master - SVG Post-processing Tool (Unified Entry Point)
+
+Processes SVG files from svg_output/ and outputs them to svg_final/.
+By default, all processing steps are executed. You can also specify
+individual steps via arguments.
+
+Usage:
+    # Execute all processing steps (recommended)
+    python3 scripts/finalize_svg.py <project_directory>
+
+    # Execute only specific steps
+    python3 scripts/finalize_svg.py <project_directory> --only embed-icons fix-rounded
+
+Examples:
+    python3 scripts/finalize_svg.py projects/my_project
+    python3 scripts/finalize_svg.py examples/ppt169_demo --only embed-icons
+
+Processing options:
+    embed-icons   - Replace <use data-icon="..."/> with actual icon SVG
+    crop-images   - Smart crop images based on preserveAspectRatio="slice"
+    fix-aspect    - Fix image aspect ratio (prevent stretching during PPT shape conversion)
+    embed-images  - Convert external images to Base64 embedded
+    flatten-text  - Convert <tspan> to independent <text> (for special renderers)
+    fix-rounded   - Convert <rect rx="..."/> to <path> (for PPT shape conversion)
+"""
+
+import os
+import sys
+import shutil
+import argparse
+from pathlib import Path
+
+# Import finalize helpers from the internal package.
+sys.path.insert(0, str(Path(__file__).parent))
+from svg_finalize.crop_images import process_svg_images as crop_images_in_svg
+from svg_finalize.embed_icons import process_svg_file as embed_icons_in_file
+from svg_finalize.embed_images import embed_images_in_svg
+from svg_finalize.fix_image_aspect import fix_image_aspect_in_svg
+
+
+def safe_print(text: str) -> None:
+    """Print text while tolerating Windows terminal encoding limits."""
+    try:
+        print(text)
+    except UnicodeEncodeError:
+        text = text.replace('✅', '[OK]').replace('❌', '[ERROR]')
+        text = text.replace('📁', '[DIR]').replace('📄', '[FILE]')
+        print(text)
+
+
+def process_flatten_text(svg_file: Path, verbose: bool = False) -> bool:
+    """Flatten text in a single SVG file (in-place modification)"""
+    try:
+        from svg_finalize.flatten_tspan import flatten_text_with_tspans
+        from xml.etree import ElementTree as ET
+
+        tree = ET.parse(str(svg_file))
+        changed = flatten_text_with_tspans(tree)
+
+        if changed:
+            tree.write(str(svg_file), encoding='unicode', xml_declaration=False)
+            if verbose:
+                safe_print(f"   [OK] {svg_file.name}: text flattened")
+        return changed
+    except Exception as e:
+        if verbose:
+            safe_print(f"   [ERROR] {svg_file.name}: {e}")
+        return False
+
+
+def process_rounded_rect(svg_file: Path, verbose: bool = False) -> int:
+    """Convert rounded rectangles in a single SVG file (in-place modification)"""
+    try:
+        from svg_finalize.svg_rect_to_path import process_svg
+
+        with open(svg_file, 'r', encoding='utf-8') as f:
+            content = f.read()
+
+        processed, count = process_svg(content, verbose=False)
+
+        if count > 0:
+            with open(svg_file, 'w', encoding='utf-8') as f:
+                f.write(processed)
+            if verbose:
+                safe_print(f"   [OK] {svg_file.name}: {count} rounded rectangle(s)")
+        return count
+    except Exception as e:
+        if verbose:
+            safe_print(f"   [ERROR] {svg_file.name}: {e}")
+        return 0
+
+
+def finalize_project(
+    project_dir: Path,
+    options: dict[str, bool],
+    dry_run: bool = False,
+    quiet: bool = False,
+) -> bool:
+    """
+    Finalize SVG files in the project
+
+    Args:
+        project_dir: Project directory path
+        options: Processing options dictionary
+        dry_run: Preview only, do not execute
+        quiet: Quiet mode, reduce output
+    """
+    svg_output = project_dir / 'svg_output'
+    svg_final = project_dir / 'svg_final'
+    icons_dir = Path(__file__).parent.parent / 'templates' / 'icons'
+
+    # Check if svg_output exists
+    if not svg_output.exists():
+        safe_print(f"[ERROR] svg_output directory not found: {svg_output}")
+        return False
+
+    # Get list of SVG files
+    svg_files = list(svg_output.glob('*.svg'))
+    if not svg_files:
+        safe_print(f"[ERROR] No SVG files in svg_output")
+        return False
+
+    if not quiet:
+        print()
+        safe_print(f"[DIR] Project: {project_dir.name}")
+        safe_print(f"[FILE] {len(svg_files)} SVG file(s)")
+
+    if dry_run:
+        safe_print("[PREVIEW] Preview mode, no operations will be performed")
+        return True
+
+    # Step 1: Copy directory
+    if svg_final.exists():
+        shutil.rmtree(svg_final)
+    shutil.copytree(svg_output, svg_final)
+
+    if not quiet:
+        print()
+
+    # Step 2: Embed icons
+    if options.get('embed_icons'):
+        if not quiet:
+            safe_print("[1/6] Embedding icons...")
+        icons_count = 0
+        for svg_file in svg_final.glob('*.svg'):
+            count = embed_icons_in_file(svg_file, icons_dir, dry_run=False, verbose=False)
+            icons_count += count
+        if not quiet:
+            if icons_count > 0:
+                safe_print(f"      {icons_count} icon(s) embedded")
+            else:
+                safe_print("      No icons")
+
+    # Step 3: Smart crop images (based on preserveAspectRatio="slice")
+    if options.get('crop_images'):
+        if not quiet:
+            safe_print("[2/6] Smart cropping images...")
+        crop_count = 0
+        crop_errors = 0
+        for svg_file in svg_final.glob('*.svg'):
+            count, errors = crop_images_in_svg(str(svg_file), dry_run=False, verbose=False)
+            crop_count += count
+            crop_errors += errors
+        if not quiet:
+            if crop_count > 0:
+                safe_print(f"      {crop_count} image(s) cropped")
+            else:
+                safe_print("      No cropping needed (no images with slice attribute)")
+
+    # Step 4: Fix image aspect ratio (prevent stretching during PPT shape conversion)
+    if options.get('fix_aspect'):
+        if not quiet:
+            safe_print("[3/6] Fixing image aspect ratios...")
+        aspect_count = 0
+        for svg_file in svg_final.glob('*.svg'):
+            count = fix_image_aspect_in_svg(str(svg_file), dry_run=False, verbose=False)
+            aspect_count += count
+        if not quiet:
+            if aspect_count > 0:
+                safe_print(f"      {aspect_count} image(s) fixed")
+            else:
+                safe_print("      No images")
+
+    # Step 5: Embed images
+    if options.get('embed_images'):
+        if not quiet:
+            safe_print("[4/6] Embedding images...")
+        images_count = 0
+        for svg_file in svg_final.glob('*.svg'):
+            count, _ = embed_images_in_svg(str(svg_file), dry_run=False)
+            images_count += count
+        if not quiet:
+            if images_count > 0:
+                safe_print(f"      {images_count} image(s) embedded")
+            else:
+                safe_print("      No images")
+
+    # Step 6: Flatten text
+    if options.get('flatten_text'):
+        if not quiet:
+            safe_print("[5/6] Flattening text...")
+        flatten_count = 0
+        for svg_file in svg_final.glob('*.svg'):
+            if process_flatten_text(svg_file, verbose=False):
+                flatten_count += 1
+        if not quiet:
+            if flatten_count > 0:
+                safe_print(f"      {flatten_count} file(s) processed")
+            else:
+                safe_print("      No processing needed")
+
+    # Step 7: Convert rounded rects to Path
+    if options.get('fix_rounded'):
+        if not quiet:
+            safe_print("[6/6] Converting rounded rects to Path...")
+        rounded_count = 0
+        for svg_file in svg_final.glob('*.svg'):
+            count = process_rounded_rect(svg_file, verbose=False)
+            rounded_count += count
+        if not quiet:
+            if rounded_count > 0:
+                safe_print(f"      {rounded_count} rounded rectangle(s) converted")
+            else:
+                safe_print("      No rounded rectangles")
+
+    # Done
+    if not quiet:
+        print()
+        safe_print("[OK] Done!")
+        print()
+        print("Next steps:")
+        print(f"  python scripts/svg_to_pptx.py \"{project_dir}\" -s final")
+
+    return True
+
+
+def main() -> None:
+    """Run the CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description='PPT Master - SVG Post-processing Tool',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog='''
+Examples:
+  %(prog)s projects/my_project           # Execute all processing (default)
+  %(prog)s projects/my_project --only embed-icons fix-rounded
+  %(prog)s projects/my_project -q        # Quiet mode
+
+Processing options (for --only):
+  embed-icons   Embed icons
+  crop-images   Smart crop images (based on preserveAspectRatio)
+  fix-aspect    Fix image aspect ratio (prevent stretching during PPT shape conversion)
+  embed-images  Embed images
+  flatten-text  Flatten text
+  fix-rounded   Convert rounded rects to Path
+        '''
+    )
+
+    parser.add_argument('project_dir', type=Path, help='Project directory path')
+    parser.add_argument('--only', nargs='+', metavar='OPTION',
+                        choices=['embed-icons', 'crop-images', 'fix-aspect', 'embed-images', 'flatten-text', 'fix-rounded'],
+                        help='Execute only specified processing steps (default: all)')
+    parser.add_argument('--dry-run', '-n', action='store_true',
+                        help='Preview only, do not execute')
+    parser.add_argument('--quiet', '-q', action='store_true',
+                        help='Quiet mode, reduce output')
+
+    args = parser.parse_args()
+
+    if not args.project_dir.exists():
+        safe_print(f"[ERROR] Project directory does not exist: {args.project_dir}")
+        sys.exit(1)
+
+    # Determine processing options
+    if args.only:
+        # Execute only specified steps
+        options = {
+            'embed_icons': 'embed-icons' in args.only,
+            'crop_images': 'crop-images' in args.only,
+            'fix_aspect': 'fix-aspect' in args.only,
+            'embed_images': 'embed-images' in args.only,
+            'flatten_text': 'flatten-text' in args.only,
+            'fix_rounded': 'fix-rounded' in args.only,
+        }
+    else:
+        # Execute all by default
+        options = {
+            'embed_icons': True,
+            'crop_images': True,
+            'fix_aspect': True,
+            'embed_images': True,
+            'flatten_text': True,
+            'fix_rounded': True,
+        }
+
+    success = finalize_project(args.project_dir, options, args.dry_run, args.quiet)
+    sys.exit(0 if success else 1)
+
+
+if __name__ == '__main__':
+    main()

package/skills/ppt-master/scripts/gemini_watermark_remover.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""
+PPT Master - Gemini Watermark Remover
+
+Removes the watermark logo from the bottom-right corner of Gemini-generated images.
+Uses a reverse blending algorithm to restore original pixels.
+
+Usage:
+    python3 scripts/gemini_watermark_remover.py <image_path>
+    python3 scripts/gemini_watermark_remover.py <image_path> -o output_path.png
+
+Examples:
+    python3 scripts/gemini_watermark_remover.py projects/demo/images/bg_01.png
+    python3 scripts/gemini_watermark_remover.py image.jpg -o image_clean.jpg
+
+Dependencies:
+    pip install Pillow numpy
+
+Notes:
+    - Supports PNG, JPG, JPEG formats
+    - Automatically detects watermark size (48px or 96px)
+    - Output file defaults to adding an _unwatermarked suffix
+"""
+
+import sys
+import argparse
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+
+# Import modules from the same directory
+sys.path.insert(0, str(Path(__file__).parent))
+
+# Algorithm parameters
+ALPHA_THRESHOLD = 0.002  # Alpha threshold; values below this are not processed
+MAX_ALPHA = 0.99  # Maximum alpha value to prevent division by zero
+LOGO_VALUE = 255  # Logo pixel value (white)
+LARGE_IMAGE_THRESHOLD = 1024
+LARGE_LOGO_SIZE = 96
+SMALL_LOGO_SIZE = 48
+LARGE_MARGIN = 64
+SMALL_MARGIN = 32
+
+# Watermark background image paths
+SCRIPT_DIR = Path(__file__).parent
+BG_48_PATH = SCRIPT_DIR / "assets" / "bg_48.png"
+BG_96_PATH = SCRIPT_DIR / "assets" / "bg_96.png"
+
+
+def detect_watermark_config(width: int, height: int) -> dict[str, int]:
+    """
+    Detect watermark configuration based on image dimensions
+
+    Args:
+        width: Image width
+        height: Image height
+
+    Returns:
+        Configuration dict containing logo_size, margin_right, margin_bottom
+    """
+    if width > LARGE_IMAGE_THRESHOLD and height > LARGE_IMAGE_THRESHOLD:
+        return {
+            "logo_size": LARGE_LOGO_SIZE,
+            "margin_right": LARGE_MARGIN,
+            "margin_bottom": LARGE_MARGIN,
+        }
+    return {
+        "logo_size": SMALL_LOGO_SIZE,
+        "margin_right": SMALL_MARGIN,
+        "margin_bottom": SMALL_MARGIN,
+    }
+
+
+def calculate_watermark_position(width: int, height: int, config: dict[str, int]) -> dict[str, int]:
+    """
+    Calculate watermark position
+
+    Args:
+        width: Image width
+        height: Image height
+        config: Watermark configuration
+
+    Returns:
+        Position dict containing x, y, width, height
+    """
+    logo_size = config["logo_size"]
+    return {
+        "x": width - config["margin_right"] - logo_size,
+        "y": height - config["margin_bottom"] - logo_size,
+        "width": logo_size,
+        "height": logo_size,
+    }
+
+
+def calculate_alpha_map(bg_image: Image.Image) -> np.ndarray:
+    """
+    Calculate the alpha channel map from the watermark background image
+
+    Args:
+        bg_image: Watermark background PNG image
+
+    Returns:
+        Alpha map array (range 0-1)
+    """
+    bg_array = np.array(bg_image.convert("RGB"), dtype=np.float32)
+    max_channel = np.max(bg_array, axis=2)
+    return max_channel / 255.0
+
+
+def remove_watermark(image: Image.Image, alpha_map: np.ndarray, position: dict) -> Image.Image:
+    """
+    Remove watermark using a reverse blending algorithm
+
+    Args:
+        image: Original image
+        alpha_map: Alpha map array
+        position: Watermark position
+
+    Returns:
+        Image with watermark removed
+    """
+    img_array = np.array(image.convert("RGBA"), dtype=np.float32)
+    x, y, w, h = position["x"], position["y"], position["width"], position["height"]
+
+    for row in range(h):
+        for col in range(w):
+            alpha = alpha_map[row, col]
+            if alpha < ALPHA_THRESHOLD:
+                continue
+            alpha = min(alpha, MAX_ALPHA)
+            one_minus_alpha = 1.0 - alpha
+
+            img_y, img_x = y + row, x + col
+            for c in range(3):
+                watermarked = img_array[img_y, img_x, c]
+                original = (watermarked - alpha * LOGO_VALUE) / one_minus_alpha
+                img_array[img_y, img_x, c] = np.clip(original, 0, 255)
+
+    return Image.fromarray(img_array.astype(np.uint8))
+
+
+def process_image(input_path: Path, output_path: Path | None = None, verbose: bool = True) -> Path:
+    """
+    Process a single image to remove its watermark
+
+    Args:
+        input_path: Input image path
+        output_path: Output image path (optional)
+        verbose: Whether to output detailed information
+
+    Returns:
+        Output file path
+    """
+    image = Image.open(input_path)
+    width, height = image.size
+
+    config = detect_watermark_config(width, height)
+    position = calculate_watermark_position(width, height, config)
+
+    if verbose:
+        print(f"  Image size: {width} x {height}")
+        print(f"  Watermark size: {config['logo_size']} x {config['logo_size']}")
+        print(f"  Watermark position: ({position['x']}, {position['y']})")
+
+    bg_path = BG_96_PATH if config["logo_size"] == 96 else BG_48_PATH
+
+    if not bg_path.exists():
+        print(f"Error: Watermark background image not found: {bg_path}")
+        sys.exit(1)
+
+    bg_image = Image.open(bg_path)
+    alpha_map = calculate_alpha_map(bg_image)
+
+    result = remove_watermark(image, alpha_map, position)
+
+    if output_path is None:
+        stem = input_path.stem
+        suffix = input_path.suffix or ".png"
+        output_path = input_path.parent / f"{stem}_unwatermarked{suffix}"
+
+    if output_path.suffix.lower() in (".jpg", ".jpeg"):
+        result = result.convert("RGB")
+
+    result.save(output_path)
+    return output_path
+
+
+def main() -> None:
+    """Run the CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description='PPT Master - Gemini Watermark Remover',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog='''
+Examples:
+    %(prog)s projects/demo/images/bg_01.png
+    %(prog)s image.jpg -o image_clean.jpg
+
+Notes:
+    - Automatically detects watermark size (96px for large images, 48px for small)
+    - Supports PNG, JPG, JPEG formats
+    - Output file defaults to adding an _unwatermarked suffix
+'''
+    )
+
+    parser.add_argument('input', type=Path, help='Input image path')
+    parser.add_argument('-o', '--output', type=Path, default=None, help='Output image path')
+    parser.add_argument('-q', '--quiet', action='store_true', help='Quiet mode')
+
+    args = parser.parse_args()
+
+    if not args.input.exists():
+        print(f"Error: File not found: {args.input}")
+        sys.exit(1)
+
+    verbose = not args.quiet
+    if verbose:
+        print("PPT Master - Gemini Watermark Remover")
+        print("=" * 40)
+        print(f"  Input file: {args.input}")
+
+    output = process_image(args.input, args.output, verbose=verbose)
+
+    if verbose:
+        print()
+        print(f"[Done] Saved to: {output}")
+
+
+if __name__ == "__main__":
+    main()