Upload 3 files

app.py

@@ -0,0 +1,544 @@
+"""
+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",
+                    image_mode="RGB"
+                )
+
+                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.Dropdown(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.Slider(
+                            visible=True, label=param[1],
+                            minimum=param[2], maximum=param[3],
+                            step=param[4], value=param[5]
+                        )
+                    else:
+                        updates[slider_components[key]] = gr.Slider(visible=False)
+            else:
+                for sl in slider_components.values():
+                    updates[sl] = gr.Slider(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 ────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    # Prefetch update in background (non-blocking)
+    import threading
+    threading.Thread(target=_fetch_update_if_needed, daemon=True).start()
+
+    demo = build_ui()
+    demo.launch()

packages.txt

@@ -0,0 +1 @@
+gmic

requirements.txt

@@ -0,0 +1,2 @@
+gradio>=4.0
+Pillow