Add minimal usage snippets and hero image

README.md

@@ -20,6 +20,8 @@ On-device **LiteRT / TFLite** conversion of the **prompt-conditioned mask decode
 [**SAM 2.1 Hiera-Tiny**](https://huggingface.co/facebook/sam2.1-hiera-tiny) (Meta, Apache-2.0),
 running **fully on the mobile GPU** via the LiteRT `CompiledModel` API (ML Drift / `LITERT_CL` delegate).
 
+![SAM 2.1 tap-to-segment running on-device (LiteRT)](demo.gif)
+
 This is the lightweight, per-click half of the SAM 2 image path. Pair it with the
 [**SAM 2.1 Hiera-Tiny image encoder**](https://huggingface.co/litert-community/SAM2.1-Hiera-Tiny-Image-Encoder)
 (run **once** per image, ~7 ms): the encoder produces the multi-scale feature pyramid, and this decoder
@@ -102,15 +104,54 @@ Eager re-authoring is **numerically exact** (`cos = 1.000`). End-to-end through
 The deepest `64×64` image embedding drifts slightly on the GPU (true-fp16 deep attention; see the encoder
 card). Mask boundaries are carried by the near-exact high-resolution features, so mask quality holds.
 
-## Usage (Android / LiteRT CompiledModel)
+## Minimal usage
+
+**Android (Kotlin, CompiledModel GPU)**
 
 ```kotlin
-// once per image — encoder on GPU
-val enc = CompiledModel.create(assets, "sam2_image_encoder_v2_fp16.tflite", Options(Accelerator.GPU), null)
-// per tap — decoder on CPU (GPU-resident but fp16-incorrect on device; see the residency note above)
-val dec = CompiledModel.create(assets, "sam2_mask_decoder_fp16.tflite", Options(Accelerator.CPU), null)
-// dec inputs (by index): 0 image_embeddings[1,256,64,64], 1 sparse[1,2,256], 2 feat_s1[1,64,128,128], 3 feat_s0[1,32,256,256]
-// dec outputs: pred_masks[1,3,256,256] logits, iou_scores[1,3]  -> pick argmax(iou), upsample, threshold 0
+// once per image - encoder on GPU (decoder-ready v2 variant from the companion repo)
+val enc = CompiledModel.create(context.assets, "sam2_tiny_image_encoder_v2_fp16.tflite",
+    CompiledModel.Options(Accelerator.GPU), null)
+// per tap - decoder on CPU (GPU-resident but fp16-incorrect on device; see the note above)
+val dec = CompiledModel.create(context.assets, "sam2_tiny_mask_decoder_fp16.tflite",
+    CompiledModel.Options(Accelerator.CPU), null)
+// dec inputs: 0 image_embeddings[1,256,64,64], 1 sparse[1,2,256],
+//             2 feat_s1[1,64,128,128], 3 feat_s0[1,32,256,256]
+// dec outputs: pred_masks[1,3,256,256] logits, iou_scores[1,3] -> argmax(iou), threshold 0
+```
+
+**Python (desktop verification)**
+
+```python
+MEAN = np.array([0.485, 0.456, 0.406], np.float32)
+STD  = np.array([0.229, 0.224, 0.225], np.float32)
+import numpy as np
+from PIL import Image
+from ai_edge_litert.interpreter import Interpreter
+
+# 1) encode once (decoder-ready v2 encoder from the companion encoder repo)
+img = Image.open("photo.jpg").convert("RGB").resize((1024, 1024))
+x = ((np.asarray(img, np.float32) / 255 - MEAN) / STD).transpose(2, 0, 1)[None]
+enc = Interpreter(model_path="sam2_tiny_image_encoder_v2_fp16.tflite"); enc.allocate_tensors()
+enc.set_tensor(enc.get_input_details()[0]["index"], x); enc.invoke()
+eo = {tuple(d["shape"]): enc.get_tensor(d["index"]) for d in enc.get_output_details()}
+
+# 2) host prompt-encode one positive tap (px, py) in 1024-space (constants: this repo)
+px, py = 512, 384
+posmat, pe1, nap = np.split(np.fromfile("prompt_encode_const.bin", np.float32), [256, 512])
+coord = 2 * np.pi * ((2 * (np.array([px, py], np.float32) + 0.5) / 1024 - 1) @ posmat.reshape(2, 128))
+tok0 = np.concatenate([np.sin(coord), np.cos(coord)]) + pe1
+sparse = np.stack([tok0, nap])[None].astype(np.float32)               # [1,2,256]
+
+# 3) decode masks (CPU)
+dec = Interpreter(model_path="sam2_tiny_mask_decoder_fp16.tflite"); dec.allocate_tensors()
+feed = {(1,2,256): sparse}; feed.update(eo)                           # match inputs by shape
+for d in dec.get_input_details(): dec.set_tensor(d["index"], feed[tuple(d["shape"])])
+dec.invoke()
+o = {len(d["shape"]): dec.get_tensor(d["index"]) for d in dec.get_output_details()}
+masks, iou = o[4], o[2]                                               # [1,3,256,256], [1,3]
+best = masks[0, iou[0].argmax()] > 0                                  # [256,256] binary mask
+Image.fromarray(best.astype(np.uint8) * 255).resize(Image.open("photo.jpg").size).save("mask.png")
 ```
 
 ## Training data & PII