File size: 7,596 Bytes
87b5db3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
import { describe, it, expect } from 'vitest';
import * as L from '../src/lib.js';

const rect = (W, H, x0, y0, x1, y1) => { const m = new Uint8Array(W * H); for (let y = y0; y <= y1; y++) for (let x = x0; x <= x1; x++) m[y * W + x] = 1; return m; };

describe('validation & geometry', () => {
  it('validateFile accepts allowed types and rejects others/oversize/empty', () => {
    expect(L.validateFile({ type: 'image/png', size: 1000 }, 'image').ok).toBe(true);
    expect(L.validateFile({ type: 'image/gif', size: 1000 }, 'image').ok).toBe(false);
    expect(L.validateFile({ type: 'image/jpeg', size: 16 * 1024 * 1024 }, 'image').error).toMatch(/15 MB/);
    expect(L.validateFile({ type: 'image/jpeg', size: 0 }, 'image').ok).toBe(false);
    expect(L.validateFile({ type: 'video/mp4', size: 5e6 }, 'video').ok).toBe(true);
    expect(L.validateFile({ type: 'video/x-msvideo', size: 5e6 }, 'video').ok).toBe(false);
    expect(L.validateFile({ type: 'video/webm', size: 61 * 1024 * 1024 }, 'video').ok).toBe(false);
  });
  it('fitSize keeps aspect, never upscales', () => {
    expect(L.fitSize(3200, 1600, 1600)).toEqual({ width: 1600, height: 800, scale: 0.5 });
    expect(L.fitSize(640, 480, 1600)).toEqual({ width: 640, height: 480, scale: 1 });
    expect(() => L.fitSize(0, 10, 10)).toThrow();
  });
  it('megapixel limit', () => { expect(L.checkMegapixels(6000, 4000)).toBe(true); expect(L.checkMegapixels(6000, 4001)).toBe(false); });
  it('displayToImage maps CSS pixels to image pixels and clamps', () => {
    const r = { left: 10, top: 20, width: 320, height: 240 };
    expect(L.displayToImage(170, 140, r, 1280, 960)).toEqual([640, 480]);
    expect(L.displayToImage(-50, 1000, r, 1280, 960)).toEqual([0, 959]);
  });
  it('normBox normalises drag direction and rejects tiny boxes', () => {
    expect(L.normBox([100, 80], [20, 10], 200, 200)).toEqual([20, 10, 100, 80]);
    expect(L.normBox([10, 10], [12, 50], 200, 200)).toBeNull();
    expect(L.normBox([-5, -5], [300, 300], 200, 100)).toEqual([0, 0, 199, 99]);
  });
});

describe('prompt building (transformers.js Sam2/Sam3 processor shapes)', () => {
  it('points + labels nested as [[[ [x,y] ]]] and [[[ l ]]]', () => {
    const p = L.buildPrompt([{ x: 1.234, y: 5, label: 1 }, { x: 7, y: 8, label: 0 }], null);
    expect(p).toEqual({ input_points: [[[[1.23, 5], [7, 8]]]], input_labels: [[[1, 0]]] });
  });
  it('box only', () => expect(L.buildPrompt([], [1, 2, 3, 4])).toEqual({ input_boxes: [[[1, 2, 3, 4]]] }));
  it('points + box', () => expect(Object.keys(L.buildPrompt([{ x: 1, y: 1, label: 1 }], [0, 0, 5, 5])).sort()).toEqual(['input_boxes', 'input_labels', 'input_points']));
  it('requires at least one prompt and caps point count', () => {
    expect(() => L.buildPrompt([], null)).toThrow(/al menos/);
    const many = Array.from({ length: 20 }, (_, i) => ({ x: i, y: i, label: 1 }));
    expect(L.buildPrompt(many, null).input_points[0][0]).toHaveLength(L.LIMITS.maxPoints);
  });
});

describe('mask post-processing', () => {
  it('bestMaskIndex picks highest predicted IoU', () => { expect(L.bestMaskIndex([0.2, 0.9, 0.5])).toBe(1); expect(L.bestMaskIndex(new Float32Array([0.7]))).toBe(0); });
  it('sliceMask extracts candidate k from [K,H,W] bool data', () => {
    const H = 2, W = 3, data = new Uint8Array(3 * H * W); data[1 * 6 + 4] = 1; data[2 * 6 + 0] = 1;
    expect(Array.from(L.sliceMask(data, 1, H, W))).toEqual([0, 0, 0, 0, 1, 0]);
    expect(L.maskArea(L.sliceMask(data, 0, H, W))).toBe(0);
  });
  it('area, bbox, centroid, describe', () => {
    const m = rect(10, 8, 2, 3, 5, 6);
    expect(L.maskArea(m)).toBe(16);
    expect(L.maskBBox(m, 10, 8)).toEqual([2, 3, 5, 6]);
    expect(L.maskCentroid(m, 10, 8)).toEqual([3.5, 4.5]);
    expect(L.describeMask(m, 10, 8)).toEqual({ area: 16, areaPct: 20, bbox: [2, 3, 5, 6] });
    expect(L.maskBBox(new Uint8Array(4), 2, 2)).toBeNull();
  });
  it('interiorPoint lies on the mask even for a ring (centroid outside)', () => {
    const W = 21, H = 21, m = new Uint8Array(W * H);
    for (let y = 0; y < H; y++) for (let x = 0; x < W; x++) { const d = Math.hypot(x - 10, y - 10); if (d >= 7 && d <= 9) m[y * W + x] = 1; }
    const p = L.interiorPoint(m, W, H);
    expect(m[p[1] * W + p[0]]).toBe(1);
  });
  it('IoU helpers', () => {
    expect(L.boxIoU([0, 0, 10, 10], [0, 0, 10, 10])).toBe(1);
    expect(L.boxIoU([0, 0, 10, 10], [5, 0, 15, 10])).toBeCloseTo(1 / 3);
    expect(L.boxIoU([0, 0, 1, 1], [2, 2, 3, 3])).toBe(0);
    const a = rect(10, 10, 0, 0, 4, 9), b = rect(10, 10, 5, 0, 9, 9);
    expect(L.maskIoU(a, a)).toBe(1); expect(L.maskIoU(a, b)).toBe(0);
    expect(L.maskIoU(rect(10, 10, 0, 0, 9, 9), a)).toBe(0.5);
    expect(() => L.maskIoU(a, new Uint8Array(3))).toThrow();
    expect(L.fractionInside(a, 10, 10, [0, 0, 4, 4])).toBe(0.5);
  });
  it('expandBox clamps to image', () => expect(L.expandBox([10, 10, 20, 20], 0.5, 22, 100)).toEqual([5, 5, 21, 25]));
  it('resizeMask nearest neighbour preserves shape', () => {
    const m = rect(4, 4, 0, 0, 1, 1), r = L.resizeMask(m, 4, 4, 8, 8);
    expect(L.maskArea(r)).toBe(16); expect(L.maskBBox(r, 8, 8)).toEqual([0, 0, 3, 3]);
  });
  it('overlayMask tints only mask pixels and draws opaque contour', () => {
    const W = 5, H = 5, rgba = new Uint8ClampedArray(W * H * 4).fill(100), m = rect(W, H, 1, 1, 3, 3);
    const o = L.overlayMask(rgba, m, W, H, [0, 200, 255], 0.5);
    expect(Array.from(o.slice(0, 4))).toEqual([100, 100, 100, 100]); // outside untouched
    const c = (2 * W + 2) * 4; expect(Array.from(o.slice(c, c + 3))).toEqual([50, 150, 178]); // interior blended
    const e = (1 * W + 1) * 4; expect(Array.from(o.slice(e, e + 3))).toEqual([0, 200, 255]); // contour opaque
    expect(rgba[c]).toBe(100); // input not mutated
  });
  it('cutout keeps masked pixels and makes the rest transparent', () => {
    const rgba = new Uint8ClampedArray([1, 2, 3, 255, 4, 5, 6, 255]);
    expect(Array.from(L.cutout(rgba, new Uint8Array([0, 1])))).toEqual([0, 0, 0, 0, 4, 5, 6, 255]);
  });
});

describe('video propagation helpers', () => {
  it('nextFramePrompt = expanded bbox + interior positive point', () => {
    const m = rect(100, 100, 40, 40, 59, 59);
    const p = L.nextFramePrompt(m, 100, 100, 0.1);
    [38.1, 38.1, 60.9, 60.9].forEach((v, k) => expect(p.box[k]).toBeCloseTo(v)); // bbox 40..59 (w=19) ±10 %
    expect(p.points).toHaveLength(1); expect(p.points[0].label).toBe(1);
    expect(m[p.points[0].y * 100 + p.points[0].x]).toBe(1);
    expect(L.nextFramePrompt(new Uint8Array(100), 10, 10)).toBeNull();
  });
  it('isLost: negative object logit, empty mask or implausible area jump', () => {
    expect(L.isLost({ objectScoreLogit: -1, area: 100, prevArea: 100 })).toBe(true);
    expect(L.isLost({ objectScoreLogit: 5, area: 0, prevArea: 100 })).toBe(true);
    expect(L.isLost({ objectScoreLogit: 5, area: 500, prevArea: 100 })).toBe(true);
    expect(L.isLost({ objectScoreLogit: 5, area: 20, prevArea: 100 })).toBe(true);
    expect(L.isLost({ objectScoreLogit: 5, area: 150, prevArea: 100 })).toBe(false);
  });
  it('sampleTimes respects fps, duration and caps', () => {
    expect(L.sampleTimes(4, 5)).toHaveLength(20);
    expect(L.sampleTimes(4, 5)[1]).toBe(0.2);
    expect(L.sampleTimes(100, 10)).toHaveLength(L.LIMITS.maxVideoFrames);
    expect(L.sampleTimes(30, 2)).toHaveLength(40); // capped at 20 s
    expect(L.sampleTimes(0, 5)).toEqual([]);
  });
  it('formatBytes uses decimal MB with Spanish comma', () => { expect(L.formatBytes(302295094)).toBe('302,3 MB'); expect(L.formatBytes(5121)).toBe('5 kB'); });
});