@idle-screens/schema 3.17.0 → 3.17.1

package/dist/index.js

@@ -10233,7 +10233,8 @@ var PATTERN_STATIONARY_AREA = 0.4;
 var PATTERN_MOVING_AREA = 0.25;
 var PATTERN_FLICKER_AREA = 0.25;
 var PATTERN_MAX_SAMPLE_TIMES = 6;
-var PERIOD_RATIO = 4 / 3;
+var LATTICE_SLACK = 1;
+var LATTICE_JITTER = 0.15;
 var PATTERN_MAX_PITCH = 0.15;
 var PATTERN_MIN_EXTENT = 2;
 var NEIGHBOUR_PITCH = 0.25;
@@ -10329,6 +10330,35 @@ function stripeExtrema(line) {
 function similarSpacing(a, b, frac) {
   return Math.abs(a - b) <= 1 + frac * Math.min(a, b);
 }
+var latticeTolerance = (p) => LATTICE_SLACK + LATTICE_JITTER * p;
+function latticeFit(xs, s, e) {
+  const n = e - s + 1;
+  let sk = 0, sx = 0, skk = 0, skx = 0;
+  for (let j = s; j <= e; j++) {
+    const k = j - s, x = xs[j];
+    sk += k;
+    sx += x;
+    skk += k * k;
+    skx += k * x;
+  }
+  const p = (n * skx - sk * sx) / (n * skk - sk * sk), a = (sx - p * sk) / n;
+  let worst = 0, at = s;
+  for (let j = s; j <= e; j++) {
+    const off = Math.abs(xs[j] - a - p * (j - s));
+    if (off > worst) {
+      worst = off;
+      at = j;
+    }
+    if (j > s) {
+      const gap = Math.abs(xs[j] - xs[j - 1] - p);
+      if (gap > worst) {
+        worst = gap;
+        at = j - s <= e - j ? j - 1 : j;
+      }
+    }
+  }
+  return { p, worst, trimStart: at - s < e - at };
+}
 function stripeRuns(ext, line, axis) {
   const runs = [];
   for (const light of [true, false]) {
@@ -10336,32 +10366,48 @@ function stripeRuns(ext, line, axis) {
     ext.forEach((e, i) => {
       if (e.light === light) idx.push(i);
     });
-    let start = 0;
-    const close = (end) => {
-      const count = end - start + 1;
-      if (count >= PATTERN_MIN_PAIRS) {
-        const xs = idx.slice(start, end + 1).map((i) => ext[i].x);
-        const periods = xs.slice(1).map((x, k) => x - xs[k]).sort((a, b) => a - b);
-        const first = idx[start], last = idx[end];
-        let swing = 0, pairs = 0;
-        for (let k = Math.max(0, first - 1); k < Math.min(ext.length - 1, last + 1); k++) {
-          swing += Math.abs(ext[k + 1].v - ext[k].v);
-          pairs++;
-        }
-        runs.push({ line, axis, from: xs[0], to: xs[xs.length - 1], period: periods[periods.length >> 1], count, light, contrast: pairs ? swing / pairs : 0 });
-      }
+    const xs = idx.map((i) => ext[i].x);
+    const close = (s, e) => {
+      while (e - s + 1 >= PATTERN_MIN_PAIRS) {
+        const fit = latticeFit(xs, s, e);
+        if (fit.worst <= latticeTolerance(fit.p)) break;
+        if (fit.trimStart) s++;
+        else e--;
+      }
+      const count = e - s + 1;
+      if (count < PATTERN_MIN_PAIRS) return;
+      const periods = xs.slice(s + 1, e + 1).map((x, k) => x - xs[s + k]).sort((a, b) => a - b);
+      const first = idx[s], last = idx[e];
+      let swing = 0, pairs = 0;
+      for (let k = Math.max(0, first - 1); k < Math.min(ext.length - 1, last + 1); k++) {
+        swing += Math.abs(ext[k + 1].v - ext[k].v);
+        pairs++;
+      }
+      runs.push({ line, axis, from: xs[s], to: xs[e], period: periods[periods.length >> 1], count, light, contrast: pairs ? swing / pairs : 0 });
     };
-    for (let k = 1; k < idx.length; k++) {
-      if (k >= 2) {
-        const p0 = ext[idx[k - 1]].x - ext[idx[k - 2]].x;
-        const p1 = ext[idx[k]].x - ext[idx[k - 1]].x;
-        if (!similarSpacing(p0, p1, PERIOD_RATIO - 1)) {
-          close(k - 1);
-          start = k - 1;
+    let start = 0, n = 0, sk = 0, sx = 0, skk = 0, skx = 0;
+    const add = (j) => {
+      const k = j - start, x = xs[j];
+      n++;
+      sk += k;
+      sx += x;
+      skk += k * k;
+      skx += k * x;
+    };
+    for (let j = 0; j < xs.length; j++) {
+      if (n >= 2) {
+        const p = (n * skx - sk * sx) / (n * skk - sk * sk), a = (sx - p * sk) / n;
+        const tol = latticeTolerance(p);
+        if (Math.abs(xs[j] - a - p * (j - start)) > tol || Math.abs(xs[j] - xs[j - 1] - p) > tol) {
+          close(start, j - 1);
+          start = j - 1;
+          n = sk = sx = skk = skx = 0;
+          add(j - 1);
         }
       }
+      add(j);
     }
-    if (idx.length) close(idx.length - 1);
+    if (xs.length) close(start, xs.length - 1);
   }
   return runs;
 }
@@ -10425,12 +10471,16 @@ function scanRaster(r) {
       }
     }
     const median = (xs) => xs.length ? [...xs].sort((a, b) => a - b)[xs.length >> 1] : 0;
+    const medians = /* @__PURE__ */ new Map();
     for (const run of flat) {
-      const sp = span.get(find(at.get(run)));
+      const root = find(at.get(run));
+      const sp = span.get(root);
       if (sp.hi - sp.lo + 1 < PATTERN_MIN_EXTENT * sp.across) continue;
+      let med = medians.get(root);
+      if (!med) medians.set(root, med = { period: median(sp.periods), slant: median(sp.slants) });
       const [along, step] = run.axis === "x" ? [r.cellX, r.cellY] : [r.cellY, r.cellX];
-      const slant = median(sp.slants) * along;
-      run.pitch = median(sp.periods) * along * (step / Math.hypot(slant, step));
+      const slant = med.slant * along;
+      run.pitch = med.period * along * (step / Math.hypot(slant, step));
       if (run.pitch <= PATTERN_MAX_PITCH) kept.push(run);
     }
   }