#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Timestamp: "2025-05-06 20:20:52 (ywatanabe)"
# File: /home/ywatanabe/proj/SciTex/manuscript/scripts/python/pptx2tif.py
# ----------------------------------------
import os
__FILE__ = "./manuscript/scripts/python/pptx2tif.py"
__DIR__ = os.path.dirname(__FILE__)
# ----------------------------------------
"""
PowerPoint to TIF Conversion Utility
This script converts PowerPoint presentations (.pptx) to TIF images,
optimized for inclusion in scientific manuscripts.
"""
import argparse
import subprocess
import sys
import tempfile
from pathlib import Path
from typing import List, Optional, Union
# Optional imports that might not be installed
LIBREOFFICE_AVAILABLE = False
PYTHON_PPT_AVAILABLE = False
PIL_AVAILABLE = False
try:
# Check for python-pptx package
from pptx import Presentation
PYTHON_PPT_AVAILABLE = True
except ImportError:
pass
try:
# Check for PIL/Pillow
from PIL import Image
PIL_AVAILABLE = True
except ImportError:
pass
def check_libreoffice_installed() -> bool:
"""Check if LibreOffice is installed."""
try:
result = subprocess.run(
["which", "libreoffice"],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True,
)
return result.returncode == 0
except Exception:
return False
def convert_pptx_to_tif_libreoffice(
input_path: str,
output_dir: Optional[str] = None,
resolution: int = 300,
verbose: bool = False,
) -> List[str]:
"""
Convert a PowerPoint file to TIF using LibreOffice.
Args:
input_path: Path to the PowerPoint file
output_dir: Directory to save output files (defaults to same directory as input)
resolution: Image resolution in DPI
verbose: Whether to print detailed information
Returns:
List of generated TIF file paths
"""
if not os.path.exists(input_path):
raise FileNotFoundError(f"PowerPoint file not found: {input_path}")
# Set output directory
if output_dir is None:
output_dir = os.path.dirname(os.path.abspath(input_path))
elif not os.path.exists(output_dir):
os.makedirs(output_dir)
input_path = os.path.abspath(input_path)
output_dir = os.path.abspath(output_dir)
# Get the base name without extension
base_name = os.path.splitext(os.path.basename(input_path))[0]
# Create a temporary directory for conversion
with tempfile.TemporaryDirectory() as temp_dir:
# Convert to TIF using LibreOffice
if verbose:
print(f"Converting {input_path} to TIF using LibreOffice...")
cmd = [
"libreoffice",
"--headless",
"--convert-to",
"tiff",
"--outdir",
temp_dir,
input_path,
]
try:
result = subprocess.run(
cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
)
if result.returncode != 0:
raise RuntimeError(f"LibreOffice conversion failed: {result.stderr}")
if verbose:
print(result.stdout)
# Find generated files
tif_files = [
os.path.join(temp_dir, f)
for f in os.listdir(temp_dir)
if f.lower().endswith((".tif", ".tiff"))
]
if not tif_files:
raise FileNotFoundError("No TIF files were generated during conversion")
# Move files to output directory with proper naming
output_files = []
for i, tif_file in enumerate(tif_files):
# For single slide presentations, use the base name
# For multi-slide presentations, append slide number
if len(tif_files) == 1:
output_name = f"{base_name}.tif"
else:
output_name = f"{base_name}_slide_{i + 1}.tif"
output_path = os.path.join(output_dir, output_name)
# Copy file to output directory
with (
open(tif_file, "rb") as contents_file,
open(output_path, "wb") as dst_file,
):
dst_file.write(contents_file.read())
output_files.append(output_path)
if verbose:
print(f"Saved: {output_path}")
return output_files
except Exception as e:
raise RuntimeError(f"Error during LibreOffice conversion: {str(e)}")
def convert_pptx_to_tif_python(
input_path: str,
output_dir: Optional[str] = None,
resolution: int = 300,
verbose: bool = False,
) -> List[str]:
"""
Convert a PowerPoint file to TIF using python-pptx and PIL.
Note: This method has limitations and may not work for all presentations.
Args:
input_path: Path to the PowerPoint file
output_dir: Directory to save output files (defaults to same directory as input)
resolution: Image resolution in DPI
verbose: Whether to print detailed information
Returns:
List of generated TIF file paths
"""
if not PYTHON_PPT_AVAILABLE:
raise ImportError("python-pptx package is not installed")
if not PIL_AVAILABLE:
raise ImportError("PIL/Pillow package is not installed")
if not os.path.exists(input_path):
raise FileNotFoundError(f"PowerPoint file not found: {input_path}")
# Set output directory
if output_dir is None:
output_dir = os.path.dirname(os.path.abspath(input_path))
elif not os.path.exists(output_dir):
os.makedirs(output_dir)
# Get the base name without extension
base_name = os.path.splitext(os.path.basename(input_path))[0]
# Load the presentation
if verbose:
print(f"Opening PowerPoint file: {input_path}")
prs = Presentation(input_path)
output_files = []
# Convert each slide
for i, slide in enumerate(prs.slides):
if verbose:
print(f"Processing slide {i + 1}/{len(prs.slides)}")
# For multi-slide presentations, append slide number
# For single slide presentations, use the base name
if len(prs.slides) == 1:
output_name = f"{base_name}.tif"
else:
output_name = f"{base_name}_slide_{i + 1}.tif"
output_path = os.path.join(output_dir, output_name)
# This is a placeholder - python-pptx cannot directly render slides
# We would need an additional library to render the slides
# Instead, we'll just output a message
print(
f"Warning: Python-only conversion is limited. Slide {i + 1} would be saved to {output_path}"
)
print(
"For better results, please install LibreOffice or use the LibreOffice conversion method"
)
# Add to output_files even though we're not creating the file
output_files.append(output_path)
return output_files
def convert_pptx_to_tif(
input_path: Union[str, Path],
output_dir: Optional[Union[str, Path]] = None,
method: str = "auto",
resolution: int = 300,
crop_whitespace: bool = True,
margin: int = 30,
verbose: bool = False,
) -> List[str]:
"""
Convert a PowerPoint file to TIF using the best available method.
Args:
input_path: Path to the PowerPoint file
output_dir: Directory to save output files (defaults to same directory as input)
method: Conversion method ('libreoffice', 'python', or 'auto')
resolution: Image resolution in DPI
crop_whitespace: Whether to crop excess whitespace
margin: Margin in pixels to add around the content area when cropping
verbose: Whether to print detailed information
Returns:
List of generated TIF file paths
"""
# Convert paths to strings if they're Path objects
if isinstance(input_path, Path):
input_path = str(input_path)
if output_dir is not None and isinstance(output_dir, Path):
output_dir = str(output_dir)
# Determine the best method to use
if method == "auto":
if check_libreoffice_installed():
method = "libreoffice"
if verbose:
print("Using LibreOffice for conversion")
elif PYTHON_PPT_AVAILABLE and PIL_AVAILABLE:
method = "python"
if verbose:
print("Using python-pptx for conversion (limited functionality)")
else:
raise RuntimeError(
"No suitable conversion method available. Please install LibreOffice or "
"the python-pptx and Pillow packages."
)
# Perform the conversion
if method == "libreoffice":
output_files = convert_pptx_to_tif_libreoffice(
input_path, output_dir, resolution, verbose
)
elif method == "python":
output_files = convert_pptx_to_tif_python(
input_path, output_dir, resolution, verbose
)
else:
raise ValueError(f"Unknown conversion method: {method}")
# Crop whitespace if requested
if crop_whitespace and output_files:
if verbose:
print("\nCropping whitespace from generated images...")
# Import crop_tif dynamically to avoid circular imports
try:
from crop_tif import crop_tif
for tif_file in output_files:
if verbose:
print(f"Cropping: {tif_file}")
try:
crop_tif(tif_file, tif_file, margin, True, verbose)
except Exception as e:
print(f"Warning: Failed to crop {tif_file}: {e}")
except ImportError:
print(
"Warning: crop_tif module not available. Skipping whitespace cropping."
)
return output_files
def batch_convert_pptx_to_tif(
directory: Union[str, Path],
output_dir: Optional[Union[str, Path]] = None,
method: str = "auto",
resolution: int = 300,
crop_whitespace: bool = True,
margin: int = 30,
recursive: bool = False,
verbose: bool = False,
) -> List[str]:
"""
Convert all PowerPoint files in a directory to TIF.
Args:
directory: Directory containing PowerPoint files
output_dir: Directory to save output files (defaults to same as input)
method: Conversion method ('libreoffice', 'python', or 'auto')
resolution: Image resolution in DPI
crop_whitespace: Whether to crop excess whitespace
margin: Margin in pixels to add around the content area when cropping
recursive: Whether to process subdirectories
verbose: Whether to print detailed information
Returns:
List of generated TIF file paths
"""
# Convert paths to strings if they're Path objects
if isinstance(directory, Path):
directory = str(directory)
if output_dir is not None and isinstance(output_dir, Path):
output_dir = str(output_dir)
if not os.path.isdir(directory):
raise ValueError(f"Directory not found: {directory}")
# Get the list of PowerPoint files
pptx_files = []
if recursive:
for root, _, filenames in os.walk(directory):
for filename in filenames:
if filename.lower().endswith((".ppt", ".pptx")):
pptx_files.append(os.path.join(root, filename))
else:
pptx_files = [
os.path.join(directory, f)
for f in os.listdir(directory)
if f.lower().endswith((".ppt", ".pptx"))
]
if not pptx_files:
print(f"No PowerPoint files found in {directory}")
return []
# Process each file
all_output_files = []
for pptx_file in pptx_files:
if verbose:
print(f"\nProcessing: {pptx_file}")
# Determine output directory
if output_dir is None:
file_output_dir = os.path.dirname(pptx_file)
else:
rel_path = os.path.relpath(os.path.dirname(pptx_file), directory)
file_output_dir = os.path.join(output_dir, rel_path)
# Create the directory if it doesn't exist
if not os.path.exists(file_output_dir):
os.makedirs(file_output_dir)
# Convert the file
try:
output_files = convert_pptx_to_tif(
pptx_file,
file_output_dir,
method,
resolution,
crop_whitespace,
margin,
verbose,
)
all_output_files.extend(output_files)
except Exception as e:
print(f"Error processing {pptx_file}: {e}")
return all_output_files
def main():
"""Parse command-line arguments and execute the appropriate action."""
# Set up argument parser
parser = argparse.ArgumentParser(
description="Convert PowerPoint files to TIF format.",
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
)
# Add subparsers for the different modes
subparsers = parser.add_subparsers(dest="mode", help="Operation mode")
# Single file mode
file_parser = subparsers.add_parser("file", help="Process a single file")
file_parser.add_argument(
"-i", "--input", required=True, help="Input PowerPoint file path"
)
file_parser.add_argument(
"-o", "--output-dir", help="Output directory for TIF files"
)
# Batch mode
batch_parser = subparsers.add_parser("batch", help="Process multiple files")
batch_parser.add_argument(
"-d",
"--directory",
required=True,
help="Directory containing PowerPoint files",
)
batch_parser.add_argument(
"-o", "--output-dir", help="Output directory for TIF files"
)
batch_parser.add_argument(
"-r",
"--recursive",
action="store_true",
help="Process subdirectories recursively",
)
# Common arguments
for subparser in [file_parser, batch_parser]:
subparser.add_argument(
"--method",
choices=["auto", "libreoffice", "python"],
default="auto",
help="Conversion method to use",
)
subparser.add_argument(
"--resolution",
type=int,
default=300,
help="Output image resolution (DPI)",
)
subparser.add_argument(
"--no-crop",
action="store_true",
help="Disable automatic cropping of whitespace",
)
subparser.add_argument(
"--margin",
type=int,
default=30,
help="Margin size around the content area when cropping",
)
subparser.add_argument(
"-v",
"--verbose",
action="store_true",
help="Enable verbose output",
)
# Parse arguments
args = parser.parse_args()
# Execute the appropriate action
if args.mode == "file":
try:
output_files = convert_pptx_to_tif(
args.input,
args.output_dir,
args.method,
args.resolution,
not args.no_crop,
args.margin,
args.verbose,
)
print(f"\nConversion complete. Generated {len(output_files)} TIF file(s).")
except Exception as e:
print(f"Error: {e}")
sys.exit(1)
elif args.mode == "batch":
try:
output_files = batch_convert_pptx_to_tif(
args.directory,
args.output_dir,
args.method,
args.resolution,
not args.no_crop,
args.margin,
args.recursive,
args.verbose,
)
print(
f"\nBatch conversion complete. Generated {len(output_files)} TIF file(s)."
)
except Exception as e:
print(f"Error: {e}")
sys.exit(1)
else:
parser.print_help()
if __name__ == "__main__":
main()
# EOF
/