Create app.py

app.py

@@ -0,0 +1,381 @@
+import io
+import os
+from typing import Optional, Tuple
+
+import gradio as gr
+import numpy as np
+from PIL import Image, ImageCms, ImageOps, ImageFile, features
+
+# Ensure PIL can load large images
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+
+def detect_features() -> dict:
+    """Detect optional codec features available in this runtime."""
+    feats = {
+        "jpeg": features.check("jpg"),
+        "jpeg_2000": features.check("jpg_2000"),
+        "imagecms": hasattr(Image, "cms") or True,  # PIL bundles lcms
+    }
+    return feats
+
+
+RUNTIME_FEATURES = detect_features()
+
+
+def flatten_transparency_to_background(img: Image.Image, background_rgb: Tuple[int, int, int]) -> Image.Image:
+    """Flatten any alpha channel against a background color to get an opaque RGB image."""
+    if img.mode in ("RGBA", "LA") or (img.mode == "P" and "transparency" in img.info):
+        # Convert to RGBA to ensure alpha channel exists for compositing
+        rgba = img.convert("RGBA")
+        background = Image.new("RGBA", rgba.size, background_rgb + (255,))
+        composited = Image.alpha_composite(background, rgba)
+        return composited.convert("RGB")
+    # No alpha present
+    if img.mode != "RGB":
+        return img.convert("RGB")
+    return img
+
+
+def apply_resize(img: Image.Image, max_width: Optional[int], max_height: Optional[int], resize_method: str) -> Image.Image:
+    if not max_width and not max_height:
+        return img
+    width, height = img.size
+    target_w = max_width or width
+    target_h = max_height or height
+
+    # Compute scale while preserving aspect ratio
+    scale = min(target_w / width, target_h / height)
+    if scale >= 1.0:
+        return img
+
+    new_size = (max(1, int(width * scale)), max(1, int(height * scale)))
+
+    resample_map = {
+        "Lanczos (best)": Image.Resampling.LANCZOS,
+        "Bicubic": Image.Resampling.BICUBIC,
+        "Bilinear": Image.Resampling.BILINEAR,
+        "Nearest": Image.Resampling.NEAREST,
+    }
+    resample = resample_map.get(resize_method, Image.Resampling.LANCZOS)
+    return img.resize(new_size, resample=resample)
+
+
+def handle_color_profile(
+    img: Image.Image,
+    convert_to_srgb: bool,
+    embed_icc: bool,
+    rendering_intent: str,
+) -> Tuple[Image.Image, Optional[bytes]]:
+    """Optionally convert to sRGB and decide whether to embed ICC profile in output."""
+    icc_out: Optional[bytes] = None
+
+    # Map intent to PIL constant
+    intent_map = {
+        "Perceptual": ImageCms.Intent.PERCEPTUAL,
+        "Relative Colorimetric": ImageCms.Intent.RELATIVE_COLORIMETRIC,
+        "Saturation": ImageCms.Intent.SATURATION,
+        "Absolute Colorimetric": ImageCms.Intent.ABSOLUTE_COLORIMETRIC,
+    }
+    intent = intent_map.get(rendering_intent, ImageCms.Intent.PERCEPTUAL)
+
+    src_icc_bytes = img.info.get("icc_profile", None)
+
+    if convert_to_srgb:
+        try:
+            srgb_profile = ImageCms.createProfile("sRGB")
+            if src_icc_bytes:
+                src_profile = ImageCms.ImageCmsProfile(io.BytesIO(src_icc_bytes))
+                img = ImageCms.profileToProfile(img, src_profile, srgb_profile, renderingIntent=intent, outputMode="RGB")
+            else:
+                # Assume current is sRGB, ensure RGB mode
+                img = img.convert("RGB")
+            if embed_icc:
+                bio = io.BytesIO()
+                srgb_profile.tobytesio(bio)
+                icc_out = bio.getvalue()
+        except Exception:
+            # Fallback: at least ensure RGB mode
+            img = img.convert("RGB")
+            icc_out = src_icc_bytes if embed_icc else None
+    else:
+        # No conversion. Optionally pass-through existing ICC
+        if embed_icc and src_icc_bytes:
+            icc_out = src_icc_bytes
+        # Ensure compatible mode for JPEGs down the line
+        if img.mode not in ("RGB", "L"):
+            img = img.convert("RGB")
+
+    return img, icc_out
+
+
+def save_as_jpeg(
+    img: Image.Image,
+    quality: int,
+    subsampling: str,
+    progressive: bool,
+    optimize: bool,
+    icc_profile: Optional[bytes],
+    exif_bytes: Optional[bytes],
+) -> Tuple[bytes, str]:
+    subsampling_map = {
+        "4:4:4 (no chroma downsampling)": 0,
+        "4:2:2": 1,
+        "4:2:0": 2,
+        "Keep (automatic)": "keep",
+    }
+    subsampling_value = subsampling_map.get(subsampling, 0)
+
+    save_params = {
+        "format": "JPEG",
+        "quality": int(quality),
+        "subsampling": subsampling_value,
+        "progressive": bool(progressive),
+        "optimize": bool(optimize),
+    }
+
+    if icc_profile:
+        save_params["icc_profile"] = icc_profile
+    if exif_bytes:
+        save_params["exif"] = exif_bytes
+
+    out = io.BytesIO()
+    img.save(out, **save_params)
+    return out.getvalue(), "image/jpeg"
+
+
+def save_as_jpeg2000_lossless(
+    img: Image.Image,
+    icc_profile: Optional[bytes],
+    exif_bytes: Optional[bytes],
+) -> Tuple[Optional[bytes], Optional[str]]:
+    if not RUNTIME_FEATURES.get("jpeg_2000", False):
+        return None, None
+    # Pillow's JPEG 2000 supports lossless when quality_mode set, but Pillow API varies; using default lossless for RGB.
+    params = {"format": "JPEG2000"}
+    if icc_profile:
+        params["icc_profile"] = icc_profile
+    # EXIF is not standard in JP2; omit to avoid errors
+    out = io.BytesIO()
+    try:
+        img.save(out, **params)
+        return out.getvalue(), "image/jp2"
+    except Exception:
+        return None, None
+
+
+def format_filesize(num_bytes: int) -> str:
+    for unit in ["B", "KB", "MB", "GB"]:
+        if num_bytes < 1024.0:
+            return f"{num_bytes:.1f} {unit}"
+        num_bytes /= 1024.0
+    return f"{num_bytes:.1f} TB"
+
+
+def convert(
+    image: Image.Image,
+    quality: int,
+    subsampling: str,
+    progressive: bool,
+    optimize: bool,
+    convert_to_srgb: bool,
+    embed_icc: bool,
+    rendering_intent: str,
+    preserve_metadata: bool,
+    flatten_bg_color: str,
+    max_width: Optional[int],
+    max_height: Optional[int],
+    resize_method: str,
+    lossless_mode: bool,
+) -> Tuple[Optional[str], Optional[Image.Image], str]:
+    if image is None:
+        return None, None, "No image provided."
+
+    original_format = image.format or "PNG"
+
+    # Prepare metadata
+    exif_bytes = image.info.get("exif", None) if preserve_metadata else None
+
+    # Resize first to keep quality
+    image = apply_resize(image, max_width, max_height, resize_method)
+
+    # Color management
+    image, icc_profile = handle_color_profile(
+        image, convert_to_srgb=convert_to_srgb, embed_icc=embed_icc, rendering_intent=rendering_intent
+    )
+
+    # Flatten alpha for JPEG encoders
+    # Convert hex color like '#RRGGBB' to RGB tuple
+    bg_rgb = tuple(int(flatten_bg_color[i : i + 2], 16) for i in (1, 3, 5))
+    image_rgb = flatten_transparency_to_background(image, bg_rgb)
+
+    # Decide output based on lossless mode
+    out_bytes: Optional[bytes] = None
+    out_mime: Optional[str] = None
+    used_codec = ""
+
+    if lossless_mode:
+        # Prefer JPEG 2000 lossless if available
+        if RUNTIME_FEATURES.get("jpeg_2000", False):
+            out_bytes, out_mime = save_as_jpeg2000_lossless(image_rgb, icc_profile=icc_profile, exif_bytes=exif_bytes)
+            used_codec = "JPEG 2000 (lossless)" if out_bytes else ""
+        # If JP2 not available or failed, fall back to near-lossless baseline JPEG with safest settings
+        if out_bytes is None:
+            out_bytes, out_mime = save_as_jpeg(
+                image_rgb,
+                quality=100,
+                subsampling="4:4:4 (no chroma downsampling)",
+                progressive=False,
+                optimize=True,
+                icc_profile=icc_profile,
+                exif_bytes=exif_bytes,
+            )
+            used_codec = "Baseline JPEG (near-lossless q=100 4:4:4)"
+    else:
+        out_bytes, out_mime = save_as_jpeg(
+            image_rgb,
+            quality=quality,
+            subsampling=subsampling,
+            progressive=progressive,
+            optimize=optimize,
+            icc_profile=icc_profile,
+            exif_bytes=exif_bytes,
+        )
+        used_codec = "Baseline JPEG"
+
+    if out_bytes is None:
+        return None, None, "Encoding failed."
+
+    # Build a named output file and a small preview image
+    out_ext = ".jpg" if out_mime == "image/jpeg" else ".jp2"
+    out_name = f"converted{out_ext}"
+
+    import tempfile
+    out_path = os.path.join(tempfile.gettempdir(), out_name)
+    with open(out_path, "wb") as f:
+        f.write(out_bytes)
+
+    # Attempt to preview
+    preview_img: Optional[Image.Image] = None
+    try:
+        preview_img = Image.open(io.BytesIO(out_bytes)).copy()
+    except Exception:
+        preview_img = None
+
+    # Build report
+    original_size = None
+    try:
+        # Encode original as PNG bytes length if available from input file object attached by Gradio
+        if hasattr(image, "fp") and hasattr(image.fp, "name") and os.path.exists(image.fp.name):
+            original_size = os.path.getsize(image.fp.name)
+    except Exception:
+        original_size = None
+
+    final_size = len(out_bytes)
+    ratio_text = ""
+    if original_size:
+        ratio = final_size / original_size
+        ratio_text = f" | size ratio: {ratio:.2f}x"
+
+    feature_notes = []
+    if lossless_mode and used_codec.startswith("Baseline JPEG"):
+        feature_notes.append("Lossless mode fell back to near-lossless JPEG because JPEG 2000 support was unavailable.")
+    if not RUNTIME_FEATURES.get("jpeg_2000", False):
+        feature_notes.append("JPEG 2000 encoder not available in this runtime.")
+
+    info = (
+        f"Original: {original_format}  →  Output: {used_codec}\n"
+        f"Output size: {format_filesize(final_size)}{ratio_text}\n"
+        + ("\n".join(feature_notes) if feature_notes else "")
+    ).strip()
+
+    return out_path, preview_img, info
+
+
+with gr.Blocks(title="PNG → JPEG Converter (Advanced)") as demo:
+    gr.Markdown("""
+    **PNG → JPEG Converter (Advanced)**
+    - Convert PNG images to JPEG with fine-grained control over quality, subsampling, progressive encoding, color profiles, and metadata.
+    - Lossless mode prefers JPEG 2000 (if available), otherwise falls back to a near-lossless baseline JPEG (quality 100, 4:4:4).
+    """)
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            inp = gr.Image(type="pil", label="Input PNG")
+            run_btn = gr.Button("Convert", variant="primary")
+        with gr.Column(scale=1):
+            out_file = gr.File(label="Output File")
+            out_preview = gr.Image(type="pil", label="Preview (if supported)")
+            out_info = gr.Textbox(label="Details", lines=4)
+
+    with gr.Accordion("Encoding Options", open=True):
+        with gr.Row():
+            quality = gr.Slider(1, 100, value=90, step=1, label="JPEG Quality")
+            subsampling = gr.Dropdown(
+                [
+                    "4:4:4 (no chroma downsampling)",
+                    "4:2:2",
+                    "4:2:0",
+                    "Keep (automatic)",
+                ],
+                value="4:2:0",
+                label="Chroma Subsampling",
+            )
+        with gr.Row():
+            progressive = gr.Checkbox(value=True, label="Progressive JPEG")
+            optimize = gr.Checkbox(value=True, label="Optimize Huffman Tables")
+
+    with gr.Accordion("Color & Metadata", open=False):
+        with gr.Row():
+            convert_to_srgb = gr.Checkbox(value=True, label="Convert to sRGB")
+            embed_icc = gr.Checkbox(value=True, label="Embed ICC Profile in Output")
+            rendering_intent = gr.Dropdown(
+                [
+                    "Perceptual",
+                    "Relative Colorimetric",
+                    "Saturation",
+                    "Absolute Colorimetric",
+                ],
+                value="Perceptual",
+                label="Rendering Intent",
+            )
+        preserve_metadata = gr.Checkbox(value=True, label="Preserve EXIF/metadata when possible")
+
+    with gr.Accordion("Resize & Transparency", open=False):
+        with gr.Row():
+            max_width = gr.Number(value=None, label="Max Width (px)")
+            max_height = gr.Number(value=None, label="Max Height (px)")
+            resize_method = gr.Dropdown(
+                ["Lanczos (best)", "Bicubic", "Bilinear", "Nearest"],
+                value="Lanczos (best)",
+                label="Resize Filter",
+            )
+        flatten_bg_color = gr.ColorPicker(value="#FFFFFF", label="Background Color for Transparency")
+
+    with gr.Accordion("Lossless Mode", open=False):
+        note = "JPEG 2000 available" if RUNTIME_FEATURES.get("jpeg_2000", False) else "JPEG 2000 NOT available; will use near-lossless baseline JPEG"
+        lossless_mode = gr.Checkbox(value=False, label=f"Use Lossless Mode ({note})")
+
+    run_btn.click(
+        fn=convert,
+        inputs=[
+            inp,
+            quality,
+            subsampling,
+            progressive,
+            optimize,
+            convert_to_srgb,
+            embed_icc,
+            rendering_intent,
+            preserve_metadata,
+            flatten_bg_color,
+            max_width,
+            max_height,
+            resize_method,
+            lossless_mode,
+        ],
+        outputs=[out_file, out_preview, out_info],
+    )
+
+if __name__ == "__main__":
+    demo.launch