app.py

"""
G'MIC Filter Studio — Hugging Face Spaces
Runs the full modern G'MIC CLI (from apt) with Gradio UI.
Gives access to 600+ filters including community stdlib.
"""

import gradio as gr
import subprocess
import tempfile
import shutil
import os
import sys
from pathlib import Path
from PIL import Image

# ─── PATH TO GMIC ────────────────────────────────────────────────────────────
GMIC = shutil.which("gmic") or "/usr/bin/gmic"
STDLIB_UPDATE = os.path.expanduser("~/.config/gmic/update" + "xxx" + ".gmic")
# We'll resolve the actual update file path at startup

UPDATE_FETCHED = False


def _fetch_update_if_needed():
    """Download the G'MIC community filter definitions once at startup."""
    global UPDATE_FETCHED
    if UPDATE_FETCHED:
        return
    try:
        r = subprocess.run(
            [GMIC, "update"],
            capture_output=True, text=True, timeout=30
        )
        UPDATE_FETCHED = True
    except Exception as e:
        print(f"[gmic update] warning: {e}", file=sys.stderr)
        UPDATE_FETCHED = True   # continue even if offline


def _run_gmic(input_path: str, command: str, extra_prefix: str = "") -> tuple[str | None, str]:
    """
    Run a G'MIC command on input_path, return (output_path_or_None, log).
    extra_prefix: optional gmic args before the input file (e.g. extra script loading).
    """
    _fetch_update_if_needed()

    out_path = input_path.replace(".png", "_out.png")
    # Use a fresh temp dir so filenames are safe
    with tempfile.TemporaryDirectory() as td:
        inp = os.path.join(td, "input.png")
        out = os.path.join(td, "output.png")
        shutil.copy(input_path, inp)

        cmd = [GMIC]
        if extra_prefix:
            cmd += extra_prefix.split()
        cmd += [inp] + command.split() + ["-o", out]

        try:
            result = subprocess.run(
                cmd,
                capture_output=True, text=True, timeout=120
            )
            log = (result.stdout + "\n" + result.stderr).strip()

            if os.path.exists(out):
                final = input_path.replace(".png", "_gmic_result.png")
                shutil.copy(out, final)
                return final, log
            else:
                return None, log or "G'MIC produced no output file."
        except subprocess.TimeoutExpired:
            return None, "ERROR: G'MIC timed out (>120s). Try a smaller image or simpler filter."
        except Exception as e:
            return None, f"ERROR: {e}"


def _pil_to_temp(img: Image.Image) -> str:
    tmp = tempfile.mktemp(suffix=".png")
    img.save(tmp, "PNG")
    return tmp


# ─── FILTER DEFINITIONS ──────────────────────────────────────────────────────
# Each entry: (display_name, command_template, [(param_name, label, min, max, step, default)])
# {p_name} in command_template gets replaced with slider value.
# Grouped into tabs.

FILTER_GROUPS = {

    "📄 Document Repair": [
        ("Repair Scanned Document",
         "fx_repair_scanned_doc {brightness},{contrast},{gamma},{threshold},0",
         [("brightness", "Brightness", -100, 100, 1, 0),
          ("contrast",   "Contrast",   -100, 100, 1, 20),
          ("gamma",      "Gamma",      -100, 100, 1, 0),
          ("threshold",  "Threshold %", 0,  100, 1, 50)]),

        ("Clean Text (afre)",
         "afre_cleantext {threshold},{smoothness},{sharpen}",
         [("threshold",  "Threshold",  0, 100, 1, 50),
          ("smoothness", "Smoothness", 0,  10, 1,  2),
          ("sharpen",    "Sharpen",    0, 300, 5, 50)]),

        ("Denoise (Iain fast)",
         "iain_fast_denoise_p {strength},{patch},{search}",
         [("strength", "Strength",    1, 50,  1, 15),
          ("patch",    "Patch size",  1, 15,  2,  7),
          ("search",   "Search size", 5, 30,  1, 21)]),

        ("Remove Hot Pixels",
         "fx_remove_hotpixels {threshold},{mask}",
         [("threshold", "Threshold", 0,  30, 1,  5),
          ("mask",      "Mask size", 1,   5, 1,  2)]),

        ("Upscale 2×  (Scale2x)",
         "fx_scalenx 2", []),

        ("Deinterlace",
         "deinterlace 0", []),
    ],

    "🔧 Inpainting": [
        ("Inpaint – Patch-Based",
         "fx_inpaint_patch {patch},{overlap},{blend}",
         [("patch",   "Patch size",   5, 50, 1, 15),
          ("overlap", "Overlap",      0, 10, 1,  5),
          ("blend",   "Blend radius", 0, 10, 1,  1)]),

        ("Inpaint – Multi-Scale",
         "fx_inpaint_matchpatch {patch},{nb_scales}",
         [("patch",     "Patch size", 5, 60, 1, 11),
          ("nb_scales", "Scales",     1,  5, 1,  3)]),

        ("Fill Transparent Area",
         "fx_solidify_td {method},{nb_iters}",
         [("method",   "Method",     0, 3, 1, 0),
          ("nb_iters", "Iterations", 1, 5, 1, 1)]),
    ],

    "✨ Enhance / Restore": [
        ("Anisotropic Smooth (edge-preserving)",
         "smooth {amplitude},{sharpness},{anisotropy},{alpha},{sigma}",
         [("amplitude",  "Amplitude",  0, 100, 1,  40),
          ("sharpness",  "Sharpness",  0,   2, .1, .7),
          ("anisotropy", "Anisotropy", 0,   1, .05, .5),
          ("alpha",      "Alpha",      0,   4, .1,  .6),
          ("sigma",      "Sigma",      0,   4, .1, 1.1)]),

        ("Smooth Skin",
         "fx_smooth_skin 2,{tolerance},{smoothness},1,1,50,50,5,2,0.2,3,1,0.05,5,0,50,50",
         [("tolerance",  "Skin Tolerance", 0, 1, .05, .5),
          ("smoothness", "Smoothness",     0, 5, .1,  1.0)]),

        ("Retinex (local contrast)",
         "fx_retinex {variance},{part},{colorspace}",
         [("variance",    "Variance",    0, 600, 5, 200),
          ("part",        "Mix %",       0, 100, 5,  80),
          ("colorspace",  "Colorspace",  0,   3, 1,   1)]),

        ("DCP Dehaze",
         "jeje_dehaze {amount},{radius}",
         [("amount", "Amount", 0, 100, 1, 50),
          ("radius", "Radius", 1,  50, 1, 15)]),

        ("Sharpen (Texture)",
         "fx_sharpen_texture {amount},{scale}",
         [("amount", "Amount", 0, 300, 5,  100),
          ("scale",  "Scale",  0,   5, .1, 1.0)]),

        ("Unsharp Mask",
         "unsharp {std},{amount},{threshold}",
         [("std",       "Std dev",   .5, 10, .5,  2),
          ("amount",    "Amount",    0,   5, .1, 1.5),
          ("threshold", "Threshold", 0,  50,  1,   5)]),

        ("Normalize Local",
         "fx_normalize_tiles {size},{overlap},{normalize}",
         [("size",      "Tile size", 16, 256, 8,  48),
          ("overlap",   "Overlap",    0,  16, 1,   4),
          ("normalize", "Normalize",  0,   5, 1,   2)]),
    ],

    "🎨 Color & Tone": [
        ("Simulate Film",
         "fx_simulate_film {category},{index},{strength},{brightness},{contrast},{gamma},{hue},{saturation},{normalize},0,0,0",
         [("category",   "Category (0–9)",  0,   9, 1,  0),
          ("index",      "Film preset",     1,  10, 1,  1),
          ("strength",   "Strength",        0, 100, 5, 80),
          ("brightness", "Brightness",    -100,100, 1,  0),
          ("contrast",   "Contrast",      -100,100, 1,  0),
          ("gamma",      "Gamma",         -100,100, 1,  0),
          ("hue",        "Hue",            -180,180,5,  0),
          ("saturation", "Saturation",    -100,100, 1,  0),
          ("normalize",  "Normalize",       0,   3, 1,  0)]),

        ("Retro Fade",
         "fx_retrofade {strength},{colorfade},{vignette}",
         [("strength",  "Strength",   0, 100, 1, 50),
          ("colorfade", "Color Fade", 0, 100, 1, 30),
          ("vignette",  "Vignette",   0, 100, 1, 40)]),

        ("Color Temperature",
         "fx_tk_colortemp {temperature},{strength}",
         [("temperature", "Temperature (K)", 2000, 10000, 100, 6500),
          ("strength",    "Strength",           0,   100,   5,   80)]),

        ("Vibrance",
         "fx_vibrance {amount}",
         [("amount", "Amount", -100, 200, 1, 50)]),

        ("Color Grading",
         "jl_colorgrading {shadows},{midtones},{highlights},{saturation}",
         [("shadows",    "Shadows shift",    -50, 50, 1,  0),
          ("midtones",   "Midtones shift",   -50, 50, 1,  0),
          ("highlights", "Highlights shift", -50, 50, 1,  0),
          ("saturation", "Saturation",       -50, 50, 1,  0)]),

        ("Equalize HSV",
         "fx_hsv_equalizer {strength},{radius}",
         [("strength", "Strength", 0, 100, 1, 80),
          ("radius",   "Radius",   0,  50, 1, 20)]),
    ],

    "🖌️ Artistic": [
        ("Kuwahara Painting",
         "fx_kuwahara {radius},{sharpness}",
         [("radius",    "Radius",    1, 15, 1,  5),
          ("sharpness", "Sharpness", 0,  5, .1, 2.0)]),

        ("Brushify",
         "fx_brushify {size},{density},{opacity},{sharpness},{angle}",
         [("size",      "Brush size",    1, 30, 1,  6),
          ("density",   "Density",       0, 100,1, 50),
          ("opacity",   "Opacity",       0, 100,5, 80),
          ("sharpness", "Sharpness",     0,  10,.5, 2),
          ("angle",     "Angle (°)", -180, 180, 5,  0)]),

        ("Illustration Look",
         "fx_illustration_look {edges},{smoothness},{sharpness}",
         [("edges",      "Edges",      0, 100, 5,  50),
          ("smoothness", "Smoothness", 0,  10, .5,  3),
          ("sharpness",  "Sharpness",  0, 300, 10,100)]),

        ("Sketch (Pencil B&W)",
         "fx_sketchbw {amplitude},{edge_threshold},{smooth},{details}",
         [("amplitude",      "Amplitude",      0, 100, 1, 40),
          ("edge_threshold", "Edge threshold", 0, 100, 1, 20),
          ("smooth",         "Smoothness",     0,   5,.1, .5),
          ("details",        "Details",        0,   5,.1,  1)]),

        ("Cartoon",
         "cartoon {smooth},{sharp},{threshold},{quantize},{coeff}",
         [("smooth",    "Smooth",    0,  10, .5, 3),
          ("sharp",     "Sharp",     0, 300, 10,200),
          ("threshold", "Threshold", 0, 100,  1, 30),
          ("quantize",  "Quantize",  2,  12,  1,  8),
          ("coeff",     "Coeff",     0,   3,.1,  1)]),

        ("Vector Painting",
         "fx_vector_painting {detail}",
         [("detail", "Detail", 1, 15, 1, 7)]),

        ("Rodilius",
         "fx_rodilius {amplitude},{size},{smoothness},{sharpness}",
         [("amplitude",  "Amplitude",  0, 60, 1, 10),
          ("size",       "Size",       0, 20, 1,  6),
          ("smoothness", "Smoothness", 0,  4, .1, 1),
          ("sharpness",  "Sharpness",  0, 300,10,200)]),

        ("Poster Edges",
         "fx_poster_edges {edge_th},{smooth},{quantize}",
         [("edge_th",  "Edge threshold", 0, 100, 1, 20),
          ("smooth",   "Smoothness",     0,  10, .5, 1),
          ("quantize", "Quantize",       2,  12,  1,  8)]),
    ],

    "🔬 Analysis": [
        ("Edge Detection",
         "fx_edges {threshold}",
         [("threshold", "Threshold", 0, 100, 1, 15)]),

        ("Gradient Norm",
         "gradient_norm", []),

        ("Structure Tensor",
         "structure_tensors 0", []),

        ("Frequency Split (detail layer)",
         "-blur {radius} +[-2] -[-1] -n 0,255",
         [("radius", "Radius (blur size)", 1, 30, 1, 5)]),

        ("Local Variance Map",
         "+blur {radius} sqr[0] blur[1] {radius} sqr[1] - sqrt n 0,255",
         [("radius", "Radius", 1, 20, 1, 5)]),
    ],

}

# ─── CORE GRADIO FUNCTION ────────────────────────────────────────────────────

def apply_filter(input_image: Image.Image, filter_group: str,
                 filter_name: str, raw_command: str,
                 **slider_values) -> tuple[Image.Image | None, str]:
    """
    Main processing function called by Gradio.
    Either runs the raw_command directly, or looks up the preset.
    """
    if input_image is None:
        return None, "Please upload an image first."

    tmp_in = _pil_to_temp(input_image)

    # Decide command to run
    if raw_command.strip():
        cmd = raw_command.strip()
        log_prefix = f"[raw] {cmd}"
    else:
        # Find the filter
        filters = FILTER_GROUPS.get(filter_group, [])
        match = None
        for f in filters:
            if f[0] == filter_name:
                match = f
                break
        if match is None:
            return None, f"Filter '{filter_name}' not found in group '{filter_group}'."

        name, template, params = match
        vals = {}
        for pname, plabel, pmin, pmax, pstep, pdef in params:
            vals[pname] = slider_values.get(f"sl_{pname}", pdef)
        # Build command
        cmd = template
        for k, v in vals.items():
            cmd = cmd.replace("{" + k + "}", str(v))
        log_prefix = f"[{name}] {cmd}"

    out_path, log = _run_gmic(tmp_in, cmd)

    try:
        os.unlink(tmp_in)
    except Exception:
        pass

    if out_path and os.path.exists(out_path):
        result_img = Image.open(out_path)
        result_img = result_img.copy()
        try:
            os.unlink(out_path)
        except Exception:
            pass
        return result_img, log_prefix + "\n\n" + log
    else:
        return None, log_prefix + "\n\nFAILED:\n" + log


# ─── BUILD UI ────────────────────────────────────────────────────────────────

def build_ui():
    # All slider names across all filters
    all_params: dict[str, tuple] = {}
    for group_name, filters in FILTER_GROUPS.items():
        for fname, template, params in filters:
            for pname, plabel, pmin, pmax, pstep, pdef in params:
                key = f"sl_{pname}"
                if key not in all_params:
                    all_params[key] = (plabel, pmin, pmax, pstep, pdef)

    CSS = """
    #gmic-header { font-family: monospace; background: #0a0a0a; padding: 14px 20px;
                   border-bottom: 2px solid #d4ff00; }
    #gmic-header h1 { color: #d4ff00; font-size: 1.4em; margin: 0; letter-spacing: .08em; }
    #gmic-header p  { color: #888; font-size: .8em; margin: 4px 0 0; }
    .note { font-size: .8em; color: #888; font-family: monospace; }
    """

    with gr.Blocks(css=CSS, title="G'MIC Filter Studio") as demo:

        gr.HTML("""
        <div id="gmic-header">
          <h1>G'MIC FILTER STUDIO</h1>
          <p>Full G'MIC stdlib + community filters · runs on server · no size limit</p>
        </div>
        """)

        with gr.Row():

            # ── LEFT: inputs ──
            with gr.Column(scale=1, min_width=300):
                input_img = gr.Image(
                    type="pil", label="Input Image"
                )

                gr.HTML("<div class='note'>Upload any size. Server-side processing on CPU.</div>")

                group_dd = gr.Dropdown(
                    label="Filter Category",
                    choices=list(FILTER_GROUPS.keys()),
                    value=list(FILTER_GROUPS.keys())[0]
                )

                filter_dd = gr.Dropdown(
                    label="Filter",
                    choices=[f[0] for f in FILTER_GROUPS[list(FILTER_GROUPS.keys())[0]]],
                    value=FILTER_GROUPS[list(FILTER_GROUPS.keys())[0]][0][0]
                )

                # All sliders, shown/hidden via JS class below
                slider_components: dict[str, gr.Slider] = {}
                with gr.Group(visible=True) as param_group:
                    gr.Markdown("**Parameters**")
                    for key, (plabel, pmin, pmax, pstep, pdef) in all_params.items():
                        sl = gr.Slider(
                            minimum=pmin, maximum=pmax, step=pstep, value=pdef,
                            label=plabel, visible=False, elem_id=key
                        )
                        slider_components[key] = sl

                raw_cmd = gr.Textbox(
                    label="Raw G'MIC command (overrides preset if non-empty)",
                    placeholder="-blur 3 -edges 5\nfx_repair_scanned_doc 0,20,0,50,0\n...",
                    lines=3,
                    info="Applied directly to the input image. Ctrl+Enter to run."
                )

                apply_btn = gr.Button("▶  Apply Filter", variant="primary")

            # ── RIGHT: outputs ──
            with gr.Column(scale=1, min_width=300):
                output_img = gr.Image(type="pil", label="Result", interactive=False)
                log_box    = gr.Textbox(label="G'MIC log", lines=6, interactive=False)

                with gr.Accordion("📖 Filter Reference", open=False):
                    gr.Markdown("""
### Filters unique to G'MIC (not in ImageJ.js / Photopea)

| Category | Filter | G'MIC command |
|---|---|---|
| Document | **Repair Scanned Document** | `fx_repair_scanned_doc` |
| Inpainting | Patch-based inpaint | `fx_inpaint_patch` |
| Inpainting | Multi-scale inpaint | `fx_inpaint_matchpatch` |
| Smoothing | Anisotropic diffusion | `smooth` |
| Skin | Smooth Skin | `fx_smooth_skin` |
| Tone | Retinex | `fx_retinex` |
| Tone | DCP Dehaze | `jeje_dehaze` |
| Film | Simulate Film (600+ LUTs) | `fx_simulate_film` |
| Artistic | Brushify | `fx_brushify` |
| Artistic | Kuwahara | `fx_kuwahara` |
| B&W | Engrave / Filaments | `fx_engrave` |
| Analysis | Frequency split | pipeline |
| Upscale | Scale2x | `fx_scalenx` |
| Denoise | Iain Fast Denoise | `iain_fast_denoise_p` |

**Tip — find any filter's CLI args:**
In GIMP G'MIC plugin, set *Output Messages → Verbose (layer name)*, apply the filter,
and the layer name shows the exact CLI command. Or:
```
gmic echo '$${fx_some_filter}'
```
""")

        # ── Dynamics ──────────────────────────────────────────────

        def update_filter_list(group_name):
            filters = FILTER_GROUPS.get(group_name, [])
            choices = [f[0] for f in filters]
            val = choices[0] if choices else None
            return gr.update(choices=choices, value=val)

        def update_sliders(group_name, filter_name):
            # Find the matching filter
            filters = FILTER_GROUPS.get(group_name, [])
            match = next((f for f in filters if f[0] == filter_name), None)
            updates = {}
            if match:
                _, _, params = match
                active_pnames = {f"sl_{p[0]}" for p in params}
                for key in slider_components:
                    if key in active_pnames:
                        param = next(p for p in params if f"sl_{p[0]}" == key)
                        updates[slider_components[key]] = gr.update(
                            visible=True, label=param[1],
                            minimum=param[2], maximum=param[3],
                            step=param[4], value=param[5]
                        )
                    else:
                        updates[slider_components[key]] = gr.update(visible=False)
            else:
                for sl in slider_components.values():
                    updates[sl] = gr.update(visible=False)
            return list(updates.values())

        group_dd.change(
            update_filter_list,
            inputs=[group_dd],
            outputs=[filter_dd]
        )
        filter_dd.change(
            update_sliders,
            inputs=[group_dd, filter_dd],
            outputs=list(slider_components.values())
        )
        # Initialize slider visibility on page load
        demo.load(
            update_sliders,
            inputs=[group_dd, filter_dd],
            outputs=list(slider_components.values())
        )

        # Wire apply button
        all_slider_comps = list(slider_components.values())
        all_slider_keys  = list(slider_components.keys())

        def on_apply(input_image, group_name, filter_name, raw_command, *slider_vals):
            sv = {all_slider_keys[i]: slider_vals[i] for i in range(len(slider_vals))}
            return apply_filter(input_image, group_name, filter_name, raw_command, **sv)

        apply_btn.click(
            on_apply,
            inputs=[input_img, group_dd, filter_dd, raw_cmd] + all_slider_comps,
            outputs=[output_img, log_box]
        )

        # Also trigger on Ctrl+Enter in raw_cmd
        raw_cmd.submit(
            on_apply,
            inputs=[input_img, group_dd, filter_dd, raw_cmd] + all_slider_comps,
            outputs=[output_img, log_box]
        )

    return demo


# ─── STARTUP ────────────────────────────────────────────────────────────────

# Prefetch gmic update file in background on cold start
import threading
threading.Thread(target=_fetch_update_if_needed, daemon=True).start()

demo = build_ui()

if __name__ == "__main__":
    demo.launch()