@synsci/cli-darwin-x64 1.1.70 → 1.1.72

package/bin/skills/scientific-slides/scripts/pdf_to_images.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+"""
+PDF to Images Converter for Presentations
+
+Converts presentation PDFs to images for visual inspection and review.
+Supports multiple output formats and resolutions.
+
+Uses PyMuPDF (fitz) as the primary conversion method - no external
+dependencies required (no poppler, ghostscript, or ImageMagick needed).
+"""
+
+import argparse
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+
+# Try to import pymupdf (preferred - no external dependencies)
+try:
+    import fitz  # PyMuPDF
+
+    HAS_PYMUPDF = True
+except ImportError:
+    HAS_PYMUPDF = False
+
+
+class PDFToImagesConverter:
+    """Converts PDF presentations to images."""
+
+    def __init__(
+        self,
+        pdf_path: str,
+        output_prefix: str,
+        dpi: int = 150,
+        format: str = 'jpg',
+        first_page: Optional[int] = None,
+        last_page: Optional[int] = None,
+    ):
+        self.pdf_path = Path(pdf_path)
+        self.output_prefix = output_prefix
+        self.dpi = dpi
+        self.format = format.lower()
+        self.first_page = first_page
+        self.last_page = last_page
+
+        # Validate format
+        if self.format not in ['jpg', 'jpeg', 'png']:
+            raise ValueError(f"Unsupported format: {format}. Use jpg or png.")
+
+    def convert(self) -> List[Path]:
+        """Convert PDF to images using PyMuPDF."""
+        if not self.pdf_path.exists():
+            raise FileNotFoundError(f"PDF not found: {self.pdf_path}")
+
+        print(f"Converting: {self.pdf_path.name}")
+        print(f"Output prefix: {self.output_prefix}")
+        print(f"DPI: {self.dpi}")
+        print(f"Format: {self.format}")
+
+        if HAS_PYMUPDF:
+            return self._convert_with_pymupdf()
+        else:
+            raise RuntimeError(
+                "PyMuPDF not installed. Install it with:\n"
+                "  pip install pymupdf\n\n"
+                "PyMuPDF is a self-contained library - no external dependencies needed."
+            )
+
+    def _convert_with_pymupdf(self) -> List[Path]:
+        """Convert using PyMuPDF library (no external dependencies)."""
+        print("Using PyMuPDF (no external dependencies required)...")
+
+        # Open the PDF
+        doc = fitz.open(self.pdf_path)
+
+        # Determine page range
+        start_page = (self.first_page - 1) if self.first_page else 0
+        end_page = self.last_page if self.last_page else doc.page_count
+
+        # Calculate zoom factor from DPI (72 DPI is the base)
+        zoom = self.dpi / 72
+        matrix = fitz.Matrix(zoom, zoom)
+
+        output_files = []
+        output_dir = Path(self.output_prefix).parent
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        for page_num in range(start_page, end_page):
+            page = doc[page_num]
+
+            # Render page to pixmap
+            pixmap = page.get_pixmap(matrix=matrix)
+
+            # Determine output path
+            output_path = Path(f"{self.output_prefix}-{page_num + 1:03d}.{self.format}")
+
+            # Save the image
+            if self.format in ['jpg', 'jpeg']:
+                pixmap.save(str(output_path), output="jpeg")
+            else:
+                pixmap.save(str(output_path), output="png")
+
+            output_files.append(output_path)
+            print(f"  Created: {output_path.name}")
+
+        doc.close()
+        return output_files
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Convert presentation PDFs to images',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s presentation.pdf slides
+    → Creates slides-001.jpg, slides-002.jpg, ...
+  
+  %(prog)s presentation.pdf output/slide --dpi 300 --format png
+    → Creates output/slide-001.png, slide-002.png, ... at high resolution
+  
+  %(prog)s presentation.pdf review/s --first 5 --last 10
+    → Converts only slides 5-10
+
+Output:
+  Images are named: PREFIX-001.FORMAT, PREFIX-002.FORMAT, etc.
+  
+Resolution:
+  - 150 DPI: Good for screen review (default)
+  - 200 DPI: Higher quality for detailed inspection
+  - 300 DPI: Print quality (larger files)
+
+Requirements:
+  Install PyMuPDF (no external dependencies needed):
+    pip install pymupdf
+        """,
+    )
+
+    parser.add_argument('pdf_path', help='Path to PDF presentation')
+
+    parser.add_argument('output_prefix', help='Output filename prefix (e.g., "slides" or "output/slide")')
+
+    parser.add_argument('--dpi', '-r', type=int, default=150, help='Resolution in DPI (default: 150)')
+
+    parser.add_argument(
+        '--format', '-f', choices=['jpg', 'jpeg', 'png'], default='jpg', help='Output format (default: jpg)'
+    )
+
+    parser.add_argument('--first', type=int, help='First page to convert (1-indexed)')
+
+    parser.add_argument('--last', type=int, help='Last page to convert (1-indexed)')
+
+    args = parser.parse_args()
+
+    # Create output directory if needed
+    output_dir = Path(args.output_prefix).parent
+    if output_dir != Path('.'):
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Convert
+    try:
+        converter = PDFToImagesConverter(
+            pdf_path=args.pdf_path,
+            output_prefix=args.output_prefix,
+            dpi=args.dpi,
+            format=args.format,
+            first_page=args.first,
+            last_page=args.last,
+        )
+
+        output_files = converter.convert()
+
+        print()
+        print("=" * 60)
+        print(f"✅ Success! Created {len(output_files)} image(s)")
+        print("=" * 60)
+
+        if output_files:
+            print(f"\nFirst image: {output_files[0]}")
+            print(f"Last image: {output_files[-1]}")
+
+            # Calculate total size
+            total_size = sum(f.stat().st_size for f in output_files)
+            size_mb = total_size / (1024 * 1024)
+            print(f"Total size: {size_mb:.2f} MB")
+
+            print("\nNext steps:")
+            print("  1. Review images for layout issues")
+            print("  2. Check for text overflow or element overlap")
+            print("  3. Verify readability from distance")
+            print("  4. Document issues with slide numbers")
+
+        sys.exit(0)
+
+    except Exception as e:
+        print(f"\n❌ Error: {str(e)}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

package/bin/skills/scientific-slides/scripts/slides_to_pdf.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+"""
+Combine slide images into a single PDF presentation.
+
+This script takes multiple slide images (PNG, JPG) and combines them
+into a single PDF file, maintaining aspect ratio and quality.
+
+Usage:
+    # Combine all PNG files in a directory
+    python slides_to_pdf.py slides/*.png -o presentation.pdf
+
+    # Combine specific files in order
+    python slides_to_pdf.py slide_01.png slide_02.png slide_03.png -o presentation.pdf
+
+    # From a directory (sorted by filename)
+    python slides_to_pdf.py slides/ -o presentation.pdf
+"""
+
+import argparse
+import sys
+from pathlib import Path
+from typing import List
+
+
+try:
+    from PIL import Image
+except ImportError:
+    print("Error: Pillow library not found. Install with: pip install Pillow")
+    sys.exit(1)
+
+
+def get_image_files(paths: List[str]) -> List[Path]:
+    """
+    Get list of image files from paths (files or directories).
+
+    Args:
+        paths: List of file paths or directory paths
+
+    Returns:
+        Sorted list of image file paths
+    """
+    image_extensions = {'.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp'}
+    image_files = []
+
+    for path_str in paths:
+        path = Path(path_str)
+
+        if path.is_file():
+            if path.suffix.lower() in image_extensions:
+                image_files.append(path)
+            else:
+                print(f"Warning: Skipping non-image file: {path}")
+        elif path.is_dir():
+            # Get all images in directory
+            for ext in image_extensions:
+                image_files.extend(path.glob(f"*{ext}"))
+                image_files.extend(path.glob(f"*{ext.upper()}"))
+        else:
+            # Try glob pattern
+            parent = path.parent
+            pattern = path.name
+            if parent.exists():
+                matches = list(parent.glob(pattern))
+                for match in matches:
+                    if match.suffix.lower() in image_extensions:
+                        image_files.append(match)
+
+    # Remove duplicates and sort
+    image_files = list(set(image_files))
+    image_files.sort(key=lambda x: x.name)
+
+    return image_files
+
+
+def combine_images_to_pdf(image_paths: List[Path], output_path: Path, dpi: int = 150, verbose: bool = False) -> bool:
+    """
+    Combine multiple images into a single PDF.
+
+    Args:
+        image_paths: List of image file paths
+        output_path: Output PDF path
+        dpi: Resolution for the PDF (default: 150)
+        verbose: Print progress information
+
+    Returns:
+        True if successful, False otherwise
+    """
+    if not image_paths:
+        print("Error: No image files found")
+        return False
+
+    if verbose:
+        print(f"Combining {len(image_paths)} images into PDF...")
+
+    # Load all images
+    images = []
+    for i, img_path in enumerate(image_paths):
+        try:
+            img = Image.open(img_path)
+            # Convert to RGB if necessary (PDF doesn't support RGBA)
+            if img.mode in ('RGBA', 'P'):
+                # Create white background
+                background = Image.new('RGB', img.size, (255, 255, 255))
+                if img.mode == 'P':
+                    img = img.convert('RGBA')
+                background.paste(img, mask=img.split()[-1] if img.mode == 'RGBA' else None)
+                img = background
+            elif img.mode != 'RGB':
+                img = img.convert('RGB')
+
+            images.append(img)
+
+            if verbose:
+                print(f"  [{i + 1}/{len(image_paths)}] Loaded: {img_path.name} ({img.size[0]}x{img.size[1]})")
+        except Exception as e:
+            print(f"Error loading {img_path}: {e}")
+            return False
+
+    if not images:
+        print("Error: No images could be loaded")
+        return False
+
+    # Create output directory if needed
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Save as PDF
+    try:
+        # First image
+        first_image = images[0]
+
+        # Remaining images (if any)
+        remaining_images = images[1:] if len(images) > 1 else []
+
+        # Save to PDF
+        first_image.save(output_path, "PDF", resolution=dpi, save_all=True, append_images=remaining_images)
+
+        if verbose:
+            print(f"\n✓ PDF created: {output_path}")
+            print(f"  Total slides: {len(images)}")
+            file_size = output_path.stat().st_size
+            if file_size > 1024 * 1024:
+                print(f"  File size: {file_size / (1024 * 1024):.1f} MB")
+            else:
+                print(f"  File size: {file_size / 1024:.1f} KB")
+
+        return True
+    except Exception as e:
+        print(f"Error creating PDF: {e}")
+        return False
+    finally:
+        # Close all images
+        for img in images:
+            img.close()
+
+
+def main():
+    """Command-line interface."""
+    parser = argparse.ArgumentParser(
+        description="Combine slide images into a single PDF presentation",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Combine PNG files using glob pattern
+  python slides_to_pdf.py slides/*.png -o presentation.pdf
+  
+  # Combine specific files in order
+  python slides_to_pdf.py title.png intro.png methods.png results.png -o talk.pdf
+  
+  # Combine all images from a directory (sorted by filename)
+  python slides_to_pdf.py slides/ -o presentation.pdf
+  
+  # With custom DPI and verbose output
+  python slides_to_pdf.py slides/*.png -o presentation.pdf --dpi 200 -v
+
+Supported formats: PNG, JPG, JPEG, GIF, WEBP, BMP
+
+Tips:
+  - Name your slide images with numbers for correct ordering:
+    01_title.png, 02_intro.png, 03_methods.png, etc.
+  - Use the generate_slide_image.py script to create slides first
+  - Standard presentation aspect ratio is 16:9 (1920x1080 or 1280x720)
+        """,
+    )
+
+    parser.add_argument("images", nargs="+", help="Image files, directories, or glob patterns")
+    parser.add_argument("-o", "--output", required=True, help="Output PDF file path")
+    parser.add_argument("--dpi", type=int, default=150, help="PDF resolution in DPI (default: 150)")
+    parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
+
+    args = parser.parse_args()
+
+    # Get image files
+    image_files = get_image_files(args.images)
+
+    if not image_files:
+        print("Error: No image files found matching the specified paths")
+        print("\nUsage examples:")
+        print("  python slides_to_pdf.py slides/*.png -o presentation.pdf")
+        print("  python slides_to_pdf.py slide1.png slide2.png -o presentation.pdf")
+        sys.exit(1)
+
+    print(f"Found {len(image_files)} image(s)")
+    if args.verbose:
+        for f in image_files:
+            print(f"  - {f}")
+
+    # Combine into PDF
+    output_path = Path(args.output)
+    success = combine_images_to_pdf(image_files, output_path, dpi=args.dpi, verbose=args.verbose)
+
+    if success:
+        print(f"\n✓ PDF created: {output_path}")
+        sys.exit(0)
+    else:
+        print("\n✗ Failed to create PDF")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()