Spaces:
Running
Running
Download source/tests/sam.test.js from Segizu/rotoscopia-lab: direct link, hf CLI and curl.
- Browser
- Download file 3.7 kB
-
https://huggingface.co/spaces/Segizu/rotoscopia-lab/resolve/main/source/tests/sam.test.js
- Command line
-
hf download hf://spaces/Segizu/rotoscopia-lab/source/tests/sam.test.js
-
curl -L -o sam.test.js https://huggingface.co/spaces/Segizu/rotoscopia-lab/resolve/main/source/tests/sam.test.js
3.7 kB
| // Model-free tests of src/sam.js with a fake model/processor (checks wiring, not model quality). | |
| import { describe, it, expect } from 'vitest'; | |
| import { encodeImage, decodePrompt, trackFrames } from '../src/sam.js'; | |
| const H = 20, W = 30; | |
| function fakes({ lostAt = -1 } = {}) { | |
| const calls = { enc: 0, dec: [], proc: [] }; | |
| const processor = async (image, prompt) => { | |
| calls.proc.push(prompt); | |
| const t = (v) => ({ data: v, dims: [] }); | |
| return { pixel_values: t('px'), original_sizes: [[H, W]], reshaped_input_sizes: [[H, W]], ...(prompt ? Object.fromEntries(Object.entries(prompt).map(([k, v]) => [k, t(v)])) : {}) }; | |
| }; | |
| let frame = 0; | |
| processor.post_process_masks = async (pred) => { | |
| // 3 candidates: k=0 empty, k=1 small square at the "object" position, k=2 full image | |
| const data = new Uint8Array(3 * H * W); | |
| const ox = pred.shift; | |
| for (let y = 5; y < 10; y++) for (let x = ox; x < ox + 5; x++) data[1 * H * W + y * W + x] = 1; | |
| data.fill(1, 2 * H * W); | |
| return [{ dims: [1, 3, H, W], data }]; | |
| }; | |
| const model = async (feeds) => { | |
| calls.dec.push(feeds); | |
| const i = frame++; | |
| return { pred_masks: { shift: 2 + i * 2 }, iou_scores: { data: new Float32Array([0.1, 0.9, 0.3]) }, object_score_logits: { data: new Float32Array([i === lostAt ? -3 : 5]) } }; | |
| }; | |
| model.get_image_embeddings = async () => { calls.enc++; return { 'image_embeddings.0': 'E0', 'image_embeddings.1': 'E1', 'image_embeddings.2': 'E2' }; }; | |
| return { model, processor, calls }; | |
| } | |
| describe('sam.js core', () => { | |
| it('decodePrompt reuses cached embeddings, forwards prompts and picks best candidate', async () => { | |
| const { model, processor, calls } = fakes(); | |
| const enc = await encodeImage(model, processor, {}); | |
| const r = await decodePrompt(model, processor, {}, enc, [{ x: 3, y: 4, label: 1 }], null); | |
| expect(calls.enc).toBe(1); | |
| expect(calls.dec[0]['image_embeddings.0']).toBe('E0'); | |
| expect(calls.dec[0].input_points.data).toEqual([[[[3, 4]]]]); | |
| expect(calls.dec[0].pixel_values).toBeUndefined(); // encoder not re-run | |
| expect(r.chosen).toBe(1); expect(r.width).toBe(W); expect(r.height).toBe(H); | |
| expect(r.mask.reduce((a, b) => a + b, 0)).toBe(25); | |
| expect(r.objectScoreLogit).toBe(5); | |
| }); | |
| it('trackFrames re-prompts each frame from the previous mask and follows the moving object', async () => { | |
| const { model, processor, calls } = fakes(); | |
| const res = await trackFrames(model, processor, 4, async () => ({}), { points: [], box: [2, 5, 6, 9] }); | |
| expect(res).toHaveLength(4); | |
| expect(calls.enc).toBe(4); // one encoder pass per frame | |
| expect(calls.dec[0].input_boxes.data).toEqual([[[2, 5, 6, 9]]]); | |
| // frame 1 prompt derived from frame-0 mask (x 2..6, y 5..9): interior point (4,7) + expanded box | |
| expect(res[1].prompt.points[0]).toEqual({ x: 4, y: 7, label: 1 }); | |
| expect(res[1].prompt.box[0]).toBeCloseTo(1.6); expect(res[1].prompt.box[2]).toBeCloseTo(6.4); | |
| expect(res[3].prompt.points[0].x).toBe(8); // followed the shift of +2 px/frame | |
| expect(res.every((r) => !r.lost)).toBe(true); | |
| }); | |
| it('a lost frame does not update the prompt; stop aborts', async () => { | |
| const { model, processor } = fakes({ lostAt: 1 }); | |
| const res = await trackFrames(model, processor, 3, async () => ({}), { points: [{ x: 4, y: 7, label: 1 }], box: null }); | |
| expect(res[1].lost).toBe(true); | |
| expect(res[2].prompt).toEqual(res[1].prompt); // reused last good prompt | |
| let n = 0; | |
| const res2 = await trackFrames(fakes().model, fakes().processor, 10, async () => ({}), { points: [{ x: 1, y: 1, label: 1 }] }, { shouldStop: () => n++ >= 2 }); | |
| expect(res2).toHaveLength(2); | |
| }); | |
| }); | |