code wiki / _hdl_build / nx_parity_judge.nx
`nx_parity_judge.nx` source

↩ module page · 169 lines · 7931 B
1// nx_parity_judge.nx -- THE ORGAN EYE (operator 2026-07-16: "this workflow isnt complete until you see
2// the exact same issues i see without your or my involvement"). Given (oracle.png, nishi.png) of the SAME
3// page, it autonomously reports the failure classes a human eyeball found on the top-20 suite -- so the
4// suite self-diagnoses every run with NO human/Claude in the loop:
5//   BLANK-NISHI     nishi has almost no ink while the oracle has plenty (google: blank page scored 97.3%
6//                   parity by matching white space -- THE metric hole this organ closes)
7//   STRIP-COLLAPSE  nishi's ink is squeezed into a narrow vertical band (bing/netflix: 1-char-per-line
8//                   column collapse from a near-zero-width container)
9//   CANVAS-OFF      the two sides disagree about the page background color (hackernews: dark canvas vs beige)
10//   SPARSE-NISHI    nishi paints real ink but a fraction of the oracle's (missing bg-images/sections)
11//   CONTENT-OK      ink mass + spread comparable -- grade quality by the parity numbers
12// Ink = pixels differing from that side's own dominant background (corner-sampled) by > tol.
13// usage: nx_parity_judge <oracle.png> <nishi.png> [nishi_y_offset]   (offset skips the browser chrome bar)
14// license_tier: ORIGINAL
15import "nx_visual_diff.nx"
16const K_MAGIC_4096: i64 = 4096
17
18func rj_w(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
19func rj_n(v: i64) -> i64 { let t: *u8=sys_mmap(24); var m: i64=v; if m<0{sys_write(1,"-" as *u8,1);m=0-m} var k: i64=0; if m==0{t[0]=48 as u8;k=1} while m>0{t[k]=(48+(m%10)) as u8;m=m/10;k=k+1} let b: *u8=sys_mmap(24); var j: i64=0; while j<k{b[j]=t[k-1-j];j=j+1} sys_write(1,b,k); return 0 }
20func rj_atoi(s: *u8) -> i64 { var v: i64=0; var i: i64=0; while s[i]!=(0 as u8){ let c: i64=(s[i] as i64)&255; if c>=48 { if c<=57 { v=v*10+(c-48) } } i=i+1 } return v }
21
22// dominant background = average of the 4 corner 8x8 patches; writes r,g,b to out
23func rj_bg(im: *VdImg, yoff: i64, out: *i64) -> i64 {
  var sr: i64 = 0
  var sg: i64 = 0
  var sb: i64 = 0
  var n: i64 = 0
  var cy: i64 = 0
  while cy < 2 {
      var cx: i64 = 0
      while cx < 2 {
          var y: i64 = 0
          while y < 8 {
              var x: i64 = 0
              while x < 8 {
                  var px: i64 = x + 2
                  var py: i64 = y + 2
                  if cx == 1 { px = im.w - 26 + x }   // inset past the ~14px scrollbar strip (it polluted
                  if cy == 1 { py = (im.h - yoff) - 10 + y }   // netflix's corner sample -> ink read 999pm)
                  let o: i64 = ((py + yoff) * im.w + px) * im.nc
                  sr = sr + (im.px[o] as i64)
                  sg = sg + (im.px[o+1] as i64)
                  sb = sb + (im.px[o+2] as i64)
                  n = n + 1
                  x = x + 1
              }
              y = y + 1
          }
          cx = cx + 1
      }
      cy = cy + 1
  }
  out[0] = sr / n
  out[1] = sg / n
  out[2] = sb / n
  return 0
57}
58// ink per-mille + the narrowest column-span holding >=80% of the ink (permille of width).
59// cols = a caller-provided i64 scratch of at least im.w entries.
60func rj_ink(im: *VdImg, yoff: i64, bg: *i64, tol: i64, cols: *i64, out: *i64) -> i64 {
  var i: i64 = 0
  while i < im.w { cols[i] = 0; i = i + 1 }
  var ink: i64 = 0
  var tot: i64 = 0
  var y: i64 = 0
  let hh: i64 = im.h - yoff
  let wmax: i64 = im.w - 14          // exclude the scrollbar column from ink
  while y < hh {
      var x: i64 = 0
      while x < wmax {
          let o: i64 = ((y + yoff) * im.w + x) * im.nc
          var dr: i64 = (im.px[o] as i64) - bg[0]
          if dr < 0 { dr = 0 - dr }
          var dg: i64 = (im.px[o+1] as i64) - bg[1]
          if dg < 0 { dg = 0 - dg }
          var db: i64 = (im.px[o+2] as i64) - bg[2]
          if db < 0 { db = 0 - db }
          tot = tot + 1
          if dr > tol { ink = ink + 1; cols[x] = cols[x] + 1; x = x + 2 }
          else { if dg > tol { ink = ink + 1; cols[x] = cols[x] + 1; x = x + 2 }
          else { if db > tol { ink = ink + 1; cols[x] = cols[x] + 1; x = x + 2 }
          else { x = x + 2 } } }
      }
      y = y + 2
  }
  out[0] = 0
  if tot > 0 { out[0] = (ink * 1000) / tot }
  // narrowest window of columns covering 80% of ink (two-pointer over the column histogram)
  var total_ink: i64 = 0
  i = 0
  while i < im.w { total_ink = total_ink + cols[i]; i = i + 1 }
  out[1] = 1000
  if total_ink > 0 {
      let need: i64 = (total_ink * 8) / 10
      var lo: i64 = 0
      var hi: i64 = 0
      var acc: i64 = 0
      var best: i64 = im.w
      while hi < im.w {
          acc = acc + cols[hi]
          hi = hi + 1
          var sh: i64 = 1
          while sh == 1 {
              if acc - cols[lo] >= need { acc = acc - cols[lo]; lo = lo + 1 } else { sh = 0 }
          }
          if acc >= need { if hi - lo < best { best = hi - lo } }
      }
      out[1] = (best * 1000) / im.w
  }
  return 0
111}
112
113// classify a loaded pair; returns the class code (0 ok · 1 blank · 2 strip · 3 canvas · 4 sparse ·
114// 5 no-oracle) and prints the metric line. The gate pins these codes to the human truth set.
115func rj_classify(a: *VdImg, b: *VdImg, byoff: i64) -> i64 {
  let abg: *i64 = sys_mmap(32) as *i64
  let bbg: *i64 = sys_mmap(32) as *i64
  rj_bg(a, 0, abg)
  rj_bg(b, byoff, bbg)
  let cols: *i64 = sys_mmap((K_MAGIC_4096 * 8) as nx_size) as *i64
  let ao: *i64 = sys_mmap(32) as *i64
  let bo: *i64 = sys_mmap(32) as *i64
  rj_ink(a, 0, abg, 28, cols, ao)
  rj_ink(b, byoff, bbg, 28, cols, bo)
  // canvas delta between the two sides' dominant backgrounds
  var cd: i64 = 0
  var k: i64 = 0
  while k < 3 {
      var d: i64 = abg[k] - bbg[k]
      if d < 0 { d = 0 - d }
      cd = cd + d
      k = k + 1
  }
  cd = cd / 3
  rj_w("oracle: ink=" as *u8); rj_n(ao[0]); rj_w("pm spread80=" as *u8); rj_n(ao[1])
  rj_w("pm  nishi: ink=" as *u8); rj_n(bo[0]); rj_w("pm spread80=" as *u8); rj_n(bo[1])
  rj_w("pm  canvas-delta=" as *u8); rj_n(cd); rj_w("\n" as *u8)
  // classification (int codes -- never pointer-compare string literals; the gate pins the thresholds
  // to the HUMAN truth set = today's eyeballed suite images):
  // 0 ok · 1 blank-nishi · 2 strip-collapse · 3 canvas-off · 4 sparse-nishi · 5 no-oracle-content
  var cls: i64 = 0
  if ao[0] < 5 { cls = 5 }                                                       // oracle itself blank (bing headless-block)
  if cls == 0 { if bo[0] >= 2 { if bo[0] <= 60 { if bo[1] < 160 { if ao[1] > 320 { cls = 2 } } } } }   // narrow ink strip
  if cls == 0 { if bo[0] < 8 { if ao[0] >= 15 { if ao[0] >= bo[0] * 4 { cls = 1 } } } }               // blank vs real oracle
  if cls == 0 { if cd > 48 { cls = 3 } }
  if cls == 0 { if bo[0] * 4 < ao[0] { cls = 4 } }
  rj_w("JUDGE=" as *u8)
  if cls == 0 { rj_w("CONTENT-OK" as *u8) }
  if cls == 1 { rj_w("BLANK-NISHI" as *u8) }
  if cls == 2 { rj_w("STRIP-COLLAPSE" as *u8) }
  if cls == 3 { rj_w("CANVAS-OFF" as *u8) }
  if cls == 4 { rj_w("SPARSE-NISHI" as *u8) }
  if cls == 5 { rj_w("NO-ORACLE-CONTENT" as *u8) }
  rj_w("\n" as *u8)
  return cls
156}
157
158func main(argc: i64, argv: *i64) -> i64 {
  if argc < 3 { rj_w("usage: nx_parity_judge <oracle.png> <nishi.png> [nishi_y_offset]\n" as *u8); sys_exit(2); return 2 }
  let a: *VdImg = vd_load(argv[1] as *u8)
  if (a as i64) == 0 { rj_w("JUDGE=NO-ORACLE\n" as *u8); sys_exit(0); return 0 }
  let b: *VdImg = vd_load(argv[2] as *u8)
  if (b as i64) == 0 { rj_w("JUDGE=NO-NISHI\n" as *u8); sys_exit(0); return 0 }
  var byoff: i64 = 44
  if argc >= 4 { byoff = rj_atoi(argv[3] as *u8) }
  rj_classify(a, b, byoff)
  sys_exit(0)
  return 0
169}
nx_parity_judge.nx source

`nx_parity_judge.nx` source
