Upload 6 files

.gitignore

@@ -0,0 +1,30 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+.env
+.venv
+env/
+venv/
+ENV/
+.DS_Store
+Thumbs.db
+*.swp
+*.swo
+test_output*

LICENSE

@@ -0,0 +1,199 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Pink Pixel (https://pinkpixel.dev)
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+   ----------------------------------------------------------------------
+   Third-Party Attribution:
+   This distribution contains an ONNX export of InSPyReNet:
+   "InSPyReNet: Incongruent Salient Object Detection",
+   developed by Taehun Kim, Kunhee Kim, Joonyeong Lee, Dongmin Cha,
+   Jiho Lee, and Daijin Kim.
+   Original InSPyReNet repository: https://github.com/plemeri/InSPyReNet
+   InSPyReNet is licensed under the MIT License.

README.md

@@ -1,3 +1,143 @@
 ---
 license: apache-2.0
+pipeline_tag: image-segmentation
+tags:
+- background-removal
+- image-segmentation
+- onnx
+- onnxruntime
+- webgpu
+- salient-object-detection
+- inspyrenet
+library_name: onnx
 ---
+
+# InSPyReNet ONNX (Swin-B 1024x1024)
+
+An ONNX export of **InSPyReNet** (Incongruent Salient Object Detection) using the Swin-B transformer backbone at 1024x1024 resolution. This model outputs fine-grained alpha mattes for zero-shot background removal, hair matting, and salient object extraction.
+
+The model file `inspyrenet_swinb_1024.onnx` is self-contained (all initializers and weights are embedded directly in the 357 MB file). You can run it on CPU, CUDA, Apple Silicon via CoreML, or inside web browsers with WebGPU through ONNX Runtime.
+
+## Model Summary
+
+| Property | Value |
+|---|---|
+| Architecture | InSPyReNet (Swin-B backbone) |
+| Task | Salient Object Detection / Background Removal |
+| Format | ONNX (IR version 10, Opset 17) |
+| Model Size | 357 MB |
+| Input Tensor | `input`: `[1, 3, 1024, 1024]` (Float32, RGB) |
+| Output Tensor | `alpha`: `[1, 1, 1024, 1024]` (Float32, range `[0.0, 1.0]`) |
+| Preprocessing | Resize to 1024x1024, scale to `[0, 1]`, ImageNet mean/std |
+| License | Apache 2.0 (Upstream InSPyReNet is MIT) |
+
+## Quickstart (Python)
+
+Install `onnxruntime` and `pillow`:
+
+```bash
+pip install onnxruntime pillow numpy
+# Or for GPU support:
+# pip install onnxruntime-gpu pillow numpy
+```
+
+Run background removal in Python:
+
+```python
+import numpy as np
+import onnxruntime as ort
+from PIL import Image
+
+# 1. Load image and keep original dimensions
+img = Image.open("input.jpg").convert("RGB")
+orig_w, orig_h = img.size
+
+# 2. Resize to 1024x1024 and normalize
+resized = img.resize((1024, 1024), Image.Resampling.BILINEAR)
+arr = np.array(resized, dtype=np.float32) / 255.0
+
+mean = np.array([0.485, 0.456, 0.406], dtype=np.float32)
+std = np.array([0.229, 0.224, 0.225], dtype=np.float32)
+norm = (arr - mean) / std
+
+# 3. Shape to [1, 3, 1024, 1024]
+tensor = np.transpose(norm, (2, 0, 1))[np.newaxis, ...]
+
+# 4. Run inference
+session = ort.InferenceSession("inspyrenet_swinb_1024.onnx", providers=["CPUExecutionProvider"])
+out = session.run(None, {"input": tensor})[0]
+
+# 5. Extract alpha and resize back to original size
+alpha = (np.clip(out[0, 0], 0.0, 1.0) * 255.0).astype(np.uint8)
+alpha_img = Image.fromarray(alpha, mode="L").resize((orig_w, orig_h), Image.Resampling.BILINEAR)
+
+# 6. Save transparent cutout
+cutout = img.convert("RGBA")
+cutout.putalpha(alpha_img)
+cutout.save("cutout.png")
+```
+
+## CLI Usage
+
+This repository includes a ready-to-use Python script in `examples/infer.py`:
+
+```bash
+# Process a single image to a transparent PNG
+python examples/infer.py --image photo.jpg --output cutout.png
+
+# Process a single image on CUDA
+python examples/infer.py --image photo.jpg --provider cuda
+
+# Save only the grayscale alpha matte mask
+python examples/infer.py --image photo.jpg --mask-only --output mask.png
+
+# Batch process a folder of images
+python examples/infer.py --dir path/to/images --output-dir path/to/cutouts
+```
+
+## Browser Usage (WebGPU & WASM)
+
+You can run this model directly on client devices inside the browser using `onnxruntime-web`.
+
+A complete demo application is provided in `examples/index.html`. To test it locally:
+
+```bash
+cd examples
+python3 -m http.server 8000
+```
+
+Open `http://localhost:8000` in your browser. You can load the model via WebGPU or WASM, drag and drop any image, view the live alpha mask, and download transparent PNG cutouts.
+
+Minimal JavaScript snippet:
+
+```javascript
+import * as ort from "onnxruntime-web";
+
+// Initialize session with WebGPU
+const session = await ort.InferenceSession.create("inspyrenet_swinb_1024.onnx", {
+  executionProviders: ["webgpu"]
+});
+
+// Prepare Float32Array tensor with shape [1, 3, 1024, 1024]
+// normalized with ImageNet mean/std
+const feeds = { input: inputTensor };
+const results = await session.run(feeds);
+const alphaData = results.alpha.data; // Float32Array of 1024 * 1024 alpha values
+```
+
+## Technical Notes
+
+* **Input resolution:** The model expects an input tensor of `1x3x1024x1024`. Non-square images should be resized to 1024x1024 for inference, and the resulting alpha mask resized back to the original image dimensions.
+* **Output range:** The output values represent foreground probability between `0.0` (background) and `1.0` (foreground). Soft edges (such as hair or transparent objects) contain fractional values between `0.0` and `1.0`.
+* **Hardware acceleration:** On modern desktop GPUs (RTX series, Apple Silicon M-series), inference runs in 50 to 120 ms. On multi-core CPUs, inference typically completes in 500 to 1200 ms depending on thread count.
+
+## Upstream Research & Attribution
+
+This model is derived from the research project:
+* **Paper:** *InSPyReNet: Incongruent Salient Object Detection* (ACM MM 2023)
+* **Authors:** Taehun Kim, Kunhee Kim, Joonyeong Lee, Dongmin Cha, Jiho Lee, Daijin Kim
+* **Upstream Code:** [github.com/plemeri/InSPyReNet](https://github.com/plemeri/InSPyReNet)
+
+## License
+
+The files in this repository are licensed under the Apache 2.0 License. See [LICENSE](LICENSE) for details. Upstream research code for InSPyReNet is licensed under the MIT License.

examples/index.html

@@ -0,0 +1,624 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>InSPyReNet ONNX - Background Removal Demo</title>
+  <!-- ONNX Runtime Web -->
+  <script src="https://cdn.jsdelivr.net/npm/onnxruntime-web@1.21.0/dist/ort.all.min.js"></script>
+  <style>
+    :root {
+      --bg: #121417;
+      --card-bg: #1a1d22;
+      --border: #2d3139;
+      --text: #f0f2f5;
+      --text-muted: #9ba3af;
+      --primary: #3b82f6;
+      --primary-hover: #2563eb;
+      --success: #10b981;
+      --surface: #22262e;
+    }
+
+    * {
+      box-sizing: border-box;
+      margin: 0;
+      padding: 0;
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+    }
+
+    body {
+      background-color: var(--bg);
+      color: var(--text);
+      min-height: 100vh;
+      display: flex;
+      flex-direction: column;
+      padding: 1.5rem;
+    }
+
+    header {
+      max-width: 1100px;
+      margin: 0 auto 1.5rem auto;
+      width: 100%;
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      flex-wrap: wrap;
+      gap: 1rem;
+      border-bottom: 1px solid var(--border);
+      padding-bottom: 1rem;
+    }
+
+    .title-group h1 {
+      font-size: 1.5rem;
+      font-weight: 700;
+      letter-spacing: -0.02em;
+    }
+
+    .title-group p {
+      color: var(--text-muted);
+      font-size: 0.9rem;
+      margin-top: 0.2rem;
+    }
+
+    .status-badge {
+      display: inline-flex;
+      align-items: center;
+      gap: 0.5rem;
+      padding: 0.35rem 0.75rem;
+      background: var(--surface);
+      border: 1px solid var(--border);
+      border-radius: 9999px;
+      font-size: 0.8rem;
+      font-weight: 500;
+    }
+
+    .status-dot {
+      width: 8px;
+      height: 8px;
+      border-radius: 50%;
+      background-color: #eab308;
+    }
+    .status-dot.ready { background-color: var(--success); }
+    .status-dot.error { background-color: #ef4444; }
+
+    main {
+      max-width: 1100px;
+      margin: 0 auto;
+      width: 100%;
+      display: grid;
+      grid-template-columns: 340px 1fr;
+      gap: 1.5rem;
+      flex: 1;
+    }
+
+    @media (max-width: 840px) {
+      main {
+        grid-template-columns: 1fr;
+      }
+    }
+
+    .sidebar {
+      display: flex;
+      flex-direction: column;
+      gap: 1.25rem;
+    }
+
+    .card {
+      background: var(--card-bg);
+      border: 1px solid var(--border);
+      border-radius: 10px;
+      padding: 1.25rem;
+    }
+
+    .card h2 {
+      font-size: 1rem;
+      font-weight: 600;
+      margin-bottom: 0.75rem;
+    }
+
+    .control-group {
+      display: flex;
+      flex-direction: column;
+      gap: 0.5rem;
+      margin-bottom: 1rem;
+    }
+
+    .control-group:last-child {
+      margin-bottom: 0;
+    }
+
+    label {
+      font-size: 0.85rem;
+      color: var(--text-muted);
+      font-weight: 500;
+    }
+
+    select, button, input[type="file"] {
+      font-size: 0.9rem;
+      color: var(--text);
+    }
+
+    select {
+      background: var(--surface);
+      border: 1px solid var(--border);
+      border-radius: 6px;
+      padding: 0.6rem 0.75rem;
+      outline: none;
+      width: 100%;
+    }
+
+    .btn {
+      background: var(--primary);
+      border: 1px solid transparent;
+      border-radius: 6px;
+      padding: 0.65rem 1rem;
+      color: white;
+      font-weight: 600;
+      cursor: pointer;
+      display: inline-flex;
+      align-items: center;
+      justify-content: center;
+      gap: 0.5rem;
+      transition: background-color 0.15s ease;
+      width: 100%;
+    }
+
+    .btn:hover:not(:disabled) {
+      background: var(--primary-hover);
+    }
+
+    .btn:disabled {
+      opacity: 0.5;
+      cursor: not-allowed;
+    }
+
+    .btn-secondary {
+      background: var(--surface);
+      border: 1px solid var(--border);
+      color: var(--text);
+    }
+
+    .btn-secondary:hover:not(:disabled) {
+      background: var(--border);
+    }
+
+    .dropzone {
+      border: 2px dashed var(--border);
+      border-radius: 8px;
+      padding: 1.5rem 1rem;
+      text-align: center;
+      cursor: pointer;
+      background: var(--surface);
+      transition: border-color 0.15s ease;
+    }
+
+    .dropzone.dragover {
+      border-color: var(--primary);
+    }
+
+    .dropzone p {
+      font-size: 0.85rem;
+      color: var(--text-muted);
+      margin-top: 0.4rem;
+    }
+
+    .workspace {
+      display: flex;
+      flex-direction: column;
+      gap: 1rem;
+    }
+
+    .view-toggles {
+      display: flex;
+      gap: 0.5rem;
+      flex-wrap: wrap;
+    }
+
+    .tab-btn {
+      background: var(--surface);
+      border: 1px solid var(--border);
+      color: var(--text-muted);
+      padding: 0.45rem 0.9rem;
+      border-radius: 6px;
+      font-size: 0.85rem;
+      cursor: pointer;
+      font-weight: 500;
+    }
+
+    .tab-btn.active {
+      background: var(--primary);
+      color: white;
+      border-color: var(--primary);
+    }
+
+    .preview-container {
+      background: var(--card-bg);
+      border: 1px solid var(--border);
+      border-radius: 10px;
+      min-height: 440px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      position: relative;
+      overflow: hidden;
+      padding: 1rem;
+    }
+
+    .checkerboard {
+      background-image: 
+        linear-gradient(45deg, #1e2229 25%, transparent 25%), 
+        linear-gradient(-45deg, #1e2229 25%, transparent 25%), 
+        linear-gradient(45deg, transparent 75%, #1e2229 75%), 
+        linear-gradient(-45deg, transparent 75%, #1e2229 75%);
+      background-size: 20px 20px;
+      background-position: 0 0, 0 10px, 10px -10px, -10px 0px;
+    }
+
+    canvas {
+      max-width: 100%;
+      max-height: 600px;
+      object-fit: contain;
+      border-radius: 4px;
+      display: none;
+    }
+
+    .placeholder-msg {
+      color: var(--text-muted);
+      text-align: center;
+      font-size: 0.95rem;
+    }
+
+    .meta-bar {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      font-size: 0.85rem;
+      color: var(--text-muted);
+      flex-wrap: wrap;
+      gap: 0.5rem;
+    }
+  </style>
+</head>
+<body>
+
+  <header>
+    <div class="title-group">
+      <h1>InSPyReNet ONNX Background Removal</h1>
+      <p>Client-side background matting powered by InSPyReNet Swin-B & ONNX Runtime Web</p>
+    </div>
+    <div class="status-badge">
+      <span id="status-dot" class="status-dot"></span>
+      <span id="status-text">Model not loaded</span>
+    </div>
+  </header>
+
+  <main>
+    <div class="sidebar">
+      <div class="card">
+        <h2>1. Model Setup</h2>
+        <div class="control-group">
+          <label for="backend-select">Execution Backend</label>
+          <select id="backend-select">
+            <option value="webgpu">WebGPU (Fastest)</option>
+            <option value="wasm">WASM (CPU Fallback)</option>
+          </select>
+        </div>
+
+        <div class="control-group">
+          <button id="load-model-btn" class="btn">Load Model</button>
+        </div>
+
+        <div class="control-group">
+          <label>Or select local .onnx file</label>
+          <input type="file" id="local-model-input" accept=".onnx" style="display: none;">
+          <button id="select-model-btn" class="btn btn-secondary">Choose .onnx File</button>
+        </div>
+      </div>
+
+      <div class="card">
+        <h2>2. Image Input</h2>
+        <div id="dropzone" class="dropzone">
+          <strong>Drag & drop an image</strong>
+          <p>or click to browse</p>
+          <input type="file" id="image-input" accept="image/*" style="display: none;">
+        </div>
+
+        <div class="control-group" style="margin-top: 1rem;">
+          <button id="run-btn" class="btn" disabled>Remove Background</button>
+        </div>
+      </div>
+
+      <div class="card">
+        <h2>3. Export</h2>
+        <button id="download-btn" class="btn btn-secondary" disabled>Download Cutout (PNG)</button>
+      </div>
+    </div>
+
+    <div class="workspace">
+      <div class="meta-bar">
+        <div class="view-toggles">
+          <button class="tab-btn active" data-view="cutout">Cutout</button>
+          <button class="tab-btn" data-view="mask">Alpha Mask</button>
+          <button class="tab-btn" data-view="original">Original</button>
+        </div>
+        <span id="timing-info">Ready</span>
+      </div>
+
+      <div class="preview-container checkerboard" id="preview-box">
+        <div id="placeholder" class="placeholder-msg">
+          Upload an image and load the model to preview results
+        </div>
+        <canvas id="output-canvas"></canvas>
+      </div>
+    </div>
+  </main>
+
+  <script>
+    let session = null;
+    let originalImage = null;
+    let alphaMaskData = null; // Uint8ClampedArray for 1024x1024 or rescaled
+    let originalWidth = 0;
+    let originalHeight = 0;
+    let currentView = 'cutout';
+
+    const statusDot = document.getElementById('status-dot');
+    const statusText = document.getElementById('status-text');
+    const loadModelBtn = document.getElementById('load-model-btn');
+    const selectModelBtn = document.getElementById('select-model-btn');
+    const localModelInput = document.getElementById('local-model-input');
+    const backendSelect = document.getElementById('backend-select');
+    const dropzone = document.getElementById('dropzone');
+    const imageInput = document.getElementById('image-input');
+    const runBtn = document.getElementById('run-btn');
+    const downloadBtn = document.getElementById('download-btn');
+    const canvas = document.getElementById('output-canvas');
+    const ctx = canvas.getContext('2d');
+    const placeholder = document.getElementById('placeholder');
+    const timingInfo = document.getElementById('timing-info');
+    const tabBtns = document.querySelectorAll('.tab-btn');
+
+    const MODEL_PATH = '../inspyrenet_swinb_1024.onnx';
+    const INPUT_SIZE = 1024;
+
+    function setStatus(text, state) {
+      statusText.textContent = text;
+      statusDot.className = 'status-dot ' + (state || '');
+    }
+
+    async function initSession(source) {
+      const backend = backendSelect.value;
+      setStatus(`Loading model with ${backend.toUpperCase()}...`, '');
+      loadModelBtn.disabled = true;
+      selectModelBtn.disabled = true;
+
+      try {
+        const options = {
+          executionProviders: [backend]
+        };
+
+        if (source instanceof ArrayBuffer) {
+          session = await ort.InferenceSession.create(source, options);
+        } else {
+          session = await ort.InferenceSession.create(source, options);
+        }
+
+        setStatus(`Model ready (${backend.toUpperCase()})`, 'ready');
+        if (originalImage) runBtn.disabled = false;
+      } catch (err) {
+        console.error('Session init error:', err);
+        setStatus('Failed to load: ' + err.message, 'error');
+        loadModelBtn.disabled = false;
+        selectModelBtn.disabled = false;
+      }
+    }
+
+    loadModelBtn.addEventListener('click', () => initSession(MODEL_PATH));
+
+    selectModelBtn.addEventListener('click', () => localModelInput.click());
+    localModelInput.addEventListener('change', async (e) => {
+      const file = e.target.files[0];
+      if (!file) return;
+      const buffer = await file.arrayBuffer();
+      await initSession(buffer);
+    });
+
+    dropzone.addEventListener('click', () => imageInput.click());
+    dropzone.addEventListener('dragover', (e) => {
+      e.preventDefault();
+      dropzone.classList.add('dragover');
+    });
+    dropzone.addEventListener('dragleave', () => dropzone.classList.remove('dragover'));
+    dropzone.addEventListener('drop', (e) => {
+      e.preventDefault();
+      dropzone.classList.remove('dragover');
+      if (e.dataTransfer.files.length) handleImageFile(e.dataTransfer.files[0]);
+    });
+    imageInput.addEventListener('change', (e) => {
+      if (e.target.files.length) handleImageFile(e.target.files[0]);
+    });
+
+    function handleImageFile(file) {
+      const reader = new FileReader();
+      reader.onload = (e) => {
+        const img = new Image();
+        img.onload = () => {
+          originalImage = img;
+          originalWidth = img.naturalWidth;
+          originalHeight = img.naturalHeight;
+          alphaMaskData = null;
+          renderOriginal();
+          if (session) runBtn.disabled = false;
+          downloadBtn.disabled = true;
+          timingInfo.textContent = `Image: ${originalWidth}x${originalHeight}px`;
+        };
+        img.src = e.target.result;
+      };
+      reader.readAsDataURL(file);
+    }
+
+    function renderOriginal() {
+      if (!originalImage) return;
+      placeholder.style.display = 'none';
+      canvas.style.display = 'block';
+      canvas.width = originalWidth;
+      canvas.height = originalHeight;
+      ctx.clearRect(0, 0, canvas.width, canvas.height);
+      ctx.drawImage(originalImage, 0, 0);
+    }
+
+    // Preprocessing for InSPyReNet Swin-B 1024
+    // Normalization: ImageNet mean [0.485, 0.456, 0.406], std [0.229, 0.224, 0.225]
+    function prepareInputTensor(img) {
+      const offCanvas = document.createElement('canvas');
+      offCanvas.width = INPUT_SIZE;
+      offCanvas.height = INPUT_SIZE;
+      const offCtx = offCanvas.getContext('2d');
+      offCtx.drawImage(img, 0, 0, INPUT_SIZE, INPUT_SIZE);
+      const imgData = offCtx.getImageData(0, 0, INPUT_SIZE, INPUT_SIZE).data;
+
+      const numPixels = INPUT_SIZE * INPUT_SIZE;
+      const floatData = new Float32Array(3 * numPixels);
+
+      const mean = [0.485, 0.456, 0.406];
+      const std = [0.229, 0.224, 0.225];
+
+      for (let i = 0; i < numPixels; i++) {
+        const r = imgData[i * 4] / 255.0;
+        const g = imgData[i * 4 + 1] / 255.0;
+        const b = imgData[i * 4 + 2] / 255.0;
+
+        floatData[i] = (r - mean[0]) / std[0];                   // R channel
+        floatData[numPixels + i] = (g - mean[1]) / std[1];       // G channel
+        floatData[2 * numPixels + i] = (b - mean[2]) / std[2];   // B channel
+      }
+
+      return new ort.Tensor('float32', floatData, [1, 3, INPUT_SIZE, INPUT_SIZE]);
+    }
+
+    runBtn.addEventListener('click', async () => {
+      if (!session || !originalImage) return;
+
+      runBtn.disabled = true;
+      timingInfo.textContent = 'Running inference...';
+
+      const t0 = performance.now();
+
+      try {
+        const inputTensor = prepareInputTensor(originalImage);
+        const feeds = { input: inputTensor };
+        const results = await session.run(feeds);
+
+        const outputTensor = results[session.outputNames[0]];
+        const alphaFloat = outputTensor.data; // Float32Array of 1024*1024
+
+        // Render alpha to 1024x1024 offscreen canvas
+        const maskCanvas = document.createElement('canvas');
+        maskCanvas.width = INPUT_SIZE;
+        maskCanvas.height = INPUT_SIZE;
+        const maskCtx = maskCanvas.getContext('2d');
+        const maskImgData = maskCtx.createImageData(INPUT_SIZE, INPUT_SIZE);
+
+        for (let i = 0; i < alphaFloat.length; i++) {
+          const val = Math.min(255, Math.max(0, Math.round(alphaFloat[i] * 255)));
+          maskImgData.data[i * 4] = val;
+          maskImgData.data[i * 4 + 1] = val;
+          maskImgData.data[i * 4 + 2] = val;
+          maskImgData.data[i * 4 + 3] = 255;
+        }
+        maskCtx.putImageData(maskImgData, 0, 0);
+
+        // Resize mask back to original dimensions
+        const scaledMaskCanvas = document.createElement('canvas');
+        scaledMaskCanvas.width = originalWidth;
+        scaledMaskCanvas.height = originalHeight;
+        const scaledMaskCtx = scaledMaskCanvas.getContext('2d');
+        scaledMaskCtx.drawImage(maskCanvas, 0, 0, originalWidth, originalHeight);
+
+        alphaMaskData = scaledMaskCtx.getImageData(0, 0, originalWidth, originalHeight).data;
+
+        const elapsed = (performance.now() - t0).toFixed(1);
+        timingInfo.textContent = `Inference completed in ${elapsed}ms`;
+
+        currentView = 'cutout';
+        updateTabActive();
+        renderView();
+
+        downloadBtn.disabled = false;
+      } catch (err) {
+        console.error('Inference error:', err);
+        timingInfo.textContent = 'Error: ' + err.message;
+      } finally {
+        runBtn.disabled = false;
+      }
+    });
+
+    function renderView() {
+      if (!originalImage) return;
+
+      canvas.width = originalWidth;
+      canvas.height = originalHeight;
+
+      if (currentView === 'original' || !alphaMaskData) {
+        ctx.clearRect(0, 0, canvas.width, canvas.height);
+        ctx.drawImage(originalImage, 0, 0);
+        return;
+      }
+
+      if (currentView === 'mask') {
+        const maskImg = ctx.createImageData(originalWidth, originalHeight);
+        for (let i = 0; i < alphaMaskData.length; i += 4) {
+          const val = alphaMaskData[i];
+          maskImg.data[i] = val;
+          maskImg.data[i + 1] = val;
+          maskImg.data[i + 2] = val;
+          maskImg.data[i + 3] = 255;
+        }
+        ctx.putImageData(maskImg, 0, 0);
+        return;
+      }
+
+      // Cutout view
+      ctx.clearRect(0, 0, canvas.width, canvas.height);
+      ctx.drawImage(originalImage, 0, 0);
+      const composite = ctx.getImageData(0, 0, originalWidth, originalHeight);
+      for (let i = 0; i < alphaMaskData.length; i += 4) {
+        composite.data[i + 3] = alphaMaskData[i]; // Apply mask to alpha channel
+      }
+      ctx.putImageData(composite, 0, 0);
+    }
+
+    function updateTabActive() {
+      tabBtns.forEach(btn => {
+        if (btn.dataset.view === currentView) {
+          btn.classList.add('active');
+        } else {
+          btn.classList.remove('active');
+        }
+      });
+    }
+
+    tabBtns.forEach(btn => {
+      btn.addEventListener('click', () => {
+        currentView = btn.dataset.view;
+        updateTabActive();
+        renderView();
+      });
+    });
+
+    downloadBtn.addEventListener('click', () => {
+      if (!alphaMaskData) return;
+      const prevView = currentView;
+      currentView = 'cutout';
+      renderView();
+
+      const link = document.createElement('a');
+      link.download = 'cutout.png';
+      link.href = canvas.toDataURL('image/png');
+      link.click();
+
+      currentView = prevView;
+      renderView();
+    });
+  </script>
+</body>
+</html>

examples/infer.py

@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+"""
+PinkPixel InSPyReNet ONNX Background Removal Tool
+
+Usage:
+    python infer.py --image path/to/input.jpg --output cutout.png
+    python infer.py --dir path/to/images --output-dir path/to/output
+    python infer.py --image path/to/input.jpg --mask-only --output mask.png
+"""
+
+import argparse
+import os
+import sys
+import time
+from pathlib import Path
+from typing import List, Tuple
+
+import numpy as np
+from PIL import Image
+
+try:
+    import onnxruntime as ort
+except ImportError:
+    sys.exit(
+        "onnxruntime is required. Install it with:\n"
+        "  pip install onnxruntime  # for CPU\n"
+        "  pip install onnxruntime-gpu  # for CUDA"
+    )
+
+# ImageNet normalization statistics
+IMAGENET_MEAN = np.array([0.485, 0.456, 0.406], dtype=np.float32)
+IMAGENET_STD = np.array([0.229, 0.224, 0.225], dtype=np.float32)
+INPUT_SIZE = 1024
+
+
+def resolve_model_path(custom_path: str = None) -> Path:
+    if custom_path:
+        p = Path(custom_path)
+        if p.exists():
+            return p
+        sys.exit(f"Error: Specified model file not found at {custom_path}")
+
+    # Look in current directory or parent directory
+    candidates = [
+        Path("inspyrenet_swinb_1024.onnx"),
+        Path(__file__).resolve().parent / "inspyrenet_swinb_1024.onnx",
+        Path(__file__).resolve().parent.parent / "inspyrenet_swinb_1024.onnx",
+    ]
+    for c in candidates:
+        if c.exists():
+            return c
+
+    sys.exit(
+        "Error: inspyrenet_swinb_1024.onnx not found. "
+        "Provide the path using --model <path>"
+    )
+
+
+def create_session(model_path: Path, provider: str = "cpu") -> ort.InferenceSession:
+    providers = []
+    provider_lower = provider.lower()
+    if provider_lower == "cuda":
+        providers = ["CUDAExecutionProvider", "CPUExecutionProvider"]
+    elif provider_lower == "coreml":
+        providers = ["CoreMLExecutionProvider", "CPUExecutionProvider"]
+    elif provider_lower == "directml":
+        providers = ["DmlExecutionProvider", "CPUExecutionProvider"]
+    else:
+        providers = ["CPUExecutionProvider"]
+
+    sess_options = ort.SessionOptions()
+    sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+    return ort.InferenceSession(str(model_path), sess_options, providers=providers)
+
+
+def preprocess_image(image: Image.Image) -> Tuple[np.ndarray, Tuple[int, int]]:
+    orig_w, orig_h = image.size
+    rgb_img = image.convert("RGB")
+
+    # Resize to model resolution
+    resized = rgb_img.resize((INPUT_SIZE, INPUT_SIZE), Image.Resampling.BILINEAR)
+    arr = np.array(resized, dtype=np.float32) / 255.0
+
+    # Apply ImageNet normalization: (x - mean) / std
+    norm = (arr - IMAGENET_MEAN) / IMAGENET_STD
+
+    # Transpose HWC -> CHW and add batch dimension -> NCHW
+    tensor = np.transpose(norm, (2, 0, 1))[np.newaxis, ...]
+    return tensor, (orig_w, orig_h)
+
+
+def run_inference(
+    session: ort.InferenceSession,
+    tensor: np.ndarray,
+    orig_size: Tuple[int, int],
+    threshold: float = None,
+) -> Image.Image:
+    input_name = session.get_inputs()[0].name
+    outputs = session.run(None, {input_name: tensor})
+
+    # Model output is alpha [1, 1, 1024, 1024]
+    alpha_map = outputs[0][0, 0]
+    alpha_map = np.clip(alpha_map, 0.0, 1.0)
+
+    if threshold is not None:
+        alpha_map = np.where(alpha_map >= threshold, 1.0, 0.0)
+
+    alpha_uint8 = (alpha_map * 255.0).astype(np.uint8)
+    orig_w, orig_h = orig_size
+
+    # Resize alpha mask back to original dimensions
+    alpha_img = Image.fromarray(alpha_uint8, mode="L").resize(
+        (orig_w, orig_h), Image.Resampling.BILINEAR
+    )
+    return alpha_img
+
+
+def process_file(
+    session: ort.InferenceSession,
+    image_path: Path,
+    output_path: Path,
+    mask_only: bool = False,
+    threshold: float = None,
+):
+    t0 = time.perf_counter()
+    with Image.open(image_path) as img:
+        tensor, orig_size = preprocess_image(img)
+        alpha_mask = run_inference(session, tensor, orig_size, threshold=threshold)
+
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        if mask_only:
+            alpha_mask.save(output_path)
+        else:
+            rgba = img.convert("RGBA")
+            rgba.putalpha(alpha_mask)
+            rgba.save(output_path, format="PNG")
+
+    elapsed_ms = (time.perf_counter() - t0) * 1000
+    print(f"Processed {image_path.name} -> {output_path} ({elapsed_ms:.1f}ms)")
+
+
+def get_image_files(directory: Path) -> List[Path]:
+    extensions = {".jpg", ".jpeg", ".png", ".webp", ".bmp", ".tiff"}
+    return [p for p in directory.iterdir() if p.suffix.lower() in extensions and p.is_file()]
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="PinkPixel InSPyReNet ONNX Background Removal"
+    )
+    parser.add_argument(
+        "-i", "--image", type=str, help="Path to a single image file"
+    )
+    parser.add_argument(
+        "-d", "--dir", type=str, help="Path to directory of images to process"
+    )
+    parser.add_argument(
+        "-o", "--output", type=str, help="Path for output file (single image)"
+    )
+    parser.add_argument(
+        "--output-dir", type=str, help="Directory to save batch results"
+    )
+    parser.add_argument(
+        "--model", type=str, default=None, help="Path to inspyrenet_swinb_1024.onnx"
+    )
+    parser.add_argument(
+        "--provider",
+        type=str,
+        default="cpu",
+        choices=["cpu", "cuda", "coreml", "directml"],
+        help="ONNX execution provider (default: cpu)",
+    )
+    parser.add_argument(
+        "-m",
+        "--mask-only",
+        action="store_true",
+        help="Save grayscale alpha mask instead of transparent RGBA cutout",
+    )
+    parser.add_argument(
+        "-t",
+        "--threshold",
+        type=float,
+        default=None,
+        help="Optional binarization threshold (e.g. 0.5) for a hard edge mask",
+    )
+
+    args = parser.parse_args()
+
+    if not args.image and not args.dir:
+        parser.print_help()
+        sys.exit("\nError: Please specify either --image or --dir")
+
+    model_path = resolve_model_path(args.model)
+    print(f"Loading model: {model_path}")
+    session = create_session(model_path, provider=args.provider)
+    print(f"Session ready with providers: {session.get_providers()}")
+
+    if args.image:
+        img_path = Path(args.image)
+        if not img_path.exists():
+            sys.exit(f"Image not found: {img_path}")
+
+        if args.output:
+            out_path = Path(args.output)
+        else:
+            suffix = "_mask.png" if args.mask_only else "_cutout.png"
+            out_path = img_path.with_name(img_path.stem + suffix)
+
+        process_file(
+            session,
+            img_path,
+            out_path,
+            mask_only=args.mask_only,
+            threshold=args.threshold,
+        )
+
+    elif args.dir:
+        in_dir = Path(args.dir)
+        if not in_dir.is_dir():
+            sys.exit(f"Directory not found: {in_dir}")
+
+        out_dir = Path(args.output_dir) if args.output_dir else in_dir / "cutouts"
+        files = get_image_files(in_dir)
+        if not files:
+            sys.exit(f"No valid image files found in {in_dir}")
+
+        print(f"Found {len(files)} images to process...")
+        for f in sorted(files):
+            suffix = "_mask.png" if args.mask_only else ".png"
+            out_path = out_dir / (f.stem + suffix)
+            process_file(
+                session,
+                f,
+                out_path,
+                mask_only=args.mask_only,
+                threshold=args.threshold,
+            )
+        print("Batch processing complete.")
+
+
+if __name__ == "__main__":
+    main()

inspyrenet_swinb_1024.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f81b9ff32d84cfc7e577450b5d53ad8ddd0b9f12109747a1f2e6b984386aa97
+size 374112036