code wiki / (root) / nx_charjudge_lib.nx
`nx_charjudge_lib.nx` source

↩ module page · 653 lines · 29466 B
1// nx_charjudge_lib.nx -- CHARACTER-IMAGE JUDGE v2 core (operator 2026-08-04: "eat the debt and build to
2// actually get to sota"). v1 (composition-bimodality x palette) reproduced the human ordering and killed the
3// patch-scramble that fooled ns_assess -- but had a NAMED gameable vector: a designed smooth+noise+palette
4// collage. v2 adds the axes that close it:
5//   CONTOUR COHERENCE -- permil of edge pixels on runs >= run_min (row+col propagation). A scramble cannot
6//     carry a contour past its patch size; per-pixel noise has edges but no runs.
7//   FACE PRESENCE -- multi-scale center-surround dark-blob (iris/pupil class, anime AND photo) + PAIR geometry
8//     (two compact blobs, level, spaced). No face = capability floor 0 (a blob with no face is not 40pc of a
9//     character). Ring compactness (all 8 ring points lighter) rejects line-art edges.
10// HEADLINE = MIN(composition, palette, contour, face). Thresholds = CONF ROWS (knowledge/charjudge.conf,
11// key=value, # comments; code defaults = the 2026-08-04 battery calibration) per rules 11+17.
12// All integer, zero third-party. Plain-if only in this lib (imported-else parser landmine, debt 1784673261).
13// Buffers are mmap-per-call, bounded by call count (CLI=1, gate<16) -- not a daemon lib.
14import "nx_syscalls.nx"
15
16const CHJ_CELL: i64 = 16
17const CHJ_BUCKETS: i64 = 4096
18const CHJ_CAND_MAX: i64 = 128
19const CHJ_MAGIC_65536: i64 = 65536
20const CHJ_C_SMOOTH_T: i64 = 0
21const CHJ_C_DETAIL_T: i64 = 1
22const CHJ_C_SMOOTH_DIV: i64 = 2
23const CHJ_C_DETAIL_DIV: i64 = 3
24const CHJ_C_PAL_DIV: i64 = 4
25const CHJ_C_EDGE_T: i64 = 5
26const CHJ_C_RUN_MIN: i64 = 6
27const CHJ_C_COH_DIV: i64 = 7
28const CHJ_C_EYE_T: i64 = 8
29const CHJ_C_FACE_REQ: i64 = 9
30// ★EYE-PAIR GEOMETRY. Every one of these was an absolute PIXEL literal, which made the face axis a function
31// of RENDER SIZE rather than of the subject: on ONE mesh, 256x384 scores face_axis 1000 and 512x768 scores
32// 0. A feature window measured in raw pixels judges the resolution, and it returns 0, which reads as "the
33// subject has no face". They are config now, and the defaults below are EXACTLY the previous literals, so
34// behaviour at any resolution that already worked is unchanged by construction.
35const CHJ_C_EYE_DY: i64 = 10        // max vertical misalignment of a candidate pair
36const CHJ_C_EYE_DXMIN: i64 = 11     // min horizontal separation of a pair
37const CHJ_C_EYE_DXMAX: i64 = 12     // max horizontal separation of a pair
38const CHJ_C_PROBE_FAR: i64 = 13     // axial centre-surround probe radius
39const CHJ_C_PROBE_DIAG: i64 = 14    // diagonal centre-surround probe radius
40const CHJ_C_DEDUP_R: i64 = 15       // candidate dedup radius
41const CHJ_C_BORDER: i64 = 16        // scan border margin
42const CHJ_C_STRIDE: i64 = 17        // scan stride
43const CHJ_C_PYR_MIN: i64 = 18       // smallest pyramid level edge the scan is still meaningful on
44// ★THE WIDTH THESE PIXEL GEOMETRIES WERE CALIBRATED AT. A centre-surround probe of FIXED radius is
45// scale-variant BY CONSTRUCTION: the feature it hunts (an eye) grows with the render, so at twice the
46// width the probe ring falls INSIDE the dark region and the candidate never fires. Measured on one mesh:
47// 256x384 yields 5 candidates and face_axis 1000; 512x768 yields at most 2 across five pyramid levels and
48// face_axis 0. Lengths are therefore scaled by w/ref_w at each level; ref_w=256 makes that scaling exactly
49// 1.0 at the width the numbers came from, so every previously-working resolution is unchanged.
50// ⚠eye_t is NOT scaled -- it is a CONTRAST threshold in luma, not a length.
51const CHJ_C_REF_W: i64 = 19
52// ★CONTOUR SMOOTHING SCALE, EXPRESSED AS A DIVISOR OF run_min RATHER THAN AS ITS OWN LENGTH. The contour
53// axis defines a contour as an orientation-stable run of at least run_min pixels, so the scale at which the
54// gradient is estimated must be a fixed fraction of that SAME length. Authoring it as an independent number
55// is how two calibrated constants silently drift apart the moment either one is retuned.
56const CHJ_C_CONTOUR_BLUR_DIV: i64 = 20
57const CHJ_NCONF: i64 = 21
58// out[] slot count. The CLI allocated a raw 96 bytes, which is exactly 12 slots -- one short of the
59// diagnostics below. A byte count where a slot count belongs is how an array grows past its buffer
60// without anyone noticing, because mmap rounds to a page and the overflow reads back plausible.
61const CHJ_NOUT: i64 = 16
62
63func chj_conf_defaults(cf: *i64) -> i64 {
  cf[CHJ_C_SMOOTH_T] = 2
  cf[CHJ_C_DETAIL_T] = 10
  cf[CHJ_C_SMOOTH_DIV] = 150
  cf[CHJ_C_DETAIL_DIV] = 300
  cf[CHJ_C_PAL_DIV] = 512
  cf[CHJ_C_EDGE_T] = 12
  cf[CHJ_C_RUN_MIN] = 24
  cf[CHJ_C_COH_DIV] = 60
  cf[CHJ_C_EYE_T] = 45
  cf[CHJ_C_FACE_REQ] = 1
  cf[CHJ_C_EYE_DY] = 5
  cf[CHJ_C_EYE_DXMIN] = 8
  cf[CHJ_C_EYE_DXMAX] = 44
  cf[CHJ_C_PROBE_FAR] = 4
  cf[CHJ_C_PROBE_DIAG] = 3
  cf[CHJ_C_DEDUP_R] = 6
  cf[CHJ_C_BORDER] = 5
  cf[CHJ_C_STRIDE] = 2
  cf[CHJ_C_PYR_MIN] = 24
  cf[CHJ_C_REF_W] = 256
  // radius = run_min/8 -> a 7px kernel against a 24px run: wide enough to average out surface texture
  // whose period is a few pixels, narrow enough that a contour of the length this axis calls coherent
  // survives it. Validated below by re-running the two textured/untextured A/B pairs and the adversarial
  // scramble and collage fixtures -- not chosen by taste.
  cf[CHJ_C_CONTOUR_BLUR_DIV] = 8
  return 0
90}
91func chj_keyeq(buf: *u8, at: i64, end: i64, key: *u8) -> i64 {
  var k: i64 = 0
  var i: i64 = at
  while key[k] != (0 as u8) {
      if i >= end { return 0 }
      if buf[i] != key[k] { return 0 }
      i = i + 1
      k = k + 1
  }
  if i >= end { return 0 }
  if buf[i] != (61 as u8) { return 0 }
  return 1
103}
104func chj_slot_for(buf: *u8, at: i64, end: i64) -> i64 {
  if chj_keyeq(buf, at, end, "eye_dy" as *u8) == 1 { return CHJ_C_EYE_DY }
  if chj_keyeq(buf, at, end, "eye_dxmin" as *u8) == 1 { return CHJ_C_EYE_DXMIN }
  if chj_keyeq(buf, at, end, "eye_dxmax" as *u8) == 1 { return CHJ_C_EYE_DXMAX }
  if chj_keyeq(buf, at, end, "probe_far" as *u8) == 1 { return CHJ_C_PROBE_FAR }
  if chj_keyeq(buf, at, end, "probe_diag" as *u8) == 1 { return CHJ_C_PROBE_DIAG }
  if chj_keyeq(buf, at, end, "dedup_r" as *u8) == 1 { return CHJ_C_DEDUP_R }
  if chj_keyeq(buf, at, end, "border" as *u8) == 1 { return CHJ_C_BORDER }
  if chj_keyeq(buf, at, end, "stride" as *u8) == 1 { return CHJ_C_STRIDE }
  if chj_keyeq(buf, at, end, "pyr_min" as *u8) == 1 { return CHJ_C_PYR_MIN }
  if chj_keyeq(buf, at, end, "ref_w" as *u8) == 1 { return CHJ_C_REF_W }
  if chj_keyeq(buf, at, end, "contour_blur_div" as *u8) == 1 { return CHJ_C_CONTOUR_BLUR_DIV }
  if chj_keyeq(buf, at, end, "smooth_t" as *u8) == 1 { return CHJ_C_SMOOTH_T }
  if chj_keyeq(buf, at, end, "detail_t" as *u8) == 1 { return CHJ_C_DETAIL_T }
  if chj_keyeq(buf, at, end, "smooth_div" as *u8) == 1 { return CHJ_C_SMOOTH_DIV }
  if chj_keyeq(buf, at, end, "detail_div" as *u8) == 1 { return CHJ_C_DETAIL_DIV }
  if chj_keyeq(buf, at, end, "pal_div" as *u8) == 1 { return CHJ_C_PAL_DIV }
  if chj_keyeq(buf, at, end, "edge_t" as *u8) == 1 { return CHJ_C_EDGE_T }
  if chj_keyeq(buf, at, end, "run_min" as *u8) == 1 { return CHJ_C_RUN_MIN }
  if chj_keyeq(buf, at, end, "coh_div" as *u8) == 1 { return CHJ_C_COH_DIV }
  if chj_keyeq(buf, at, end, "eye_t" as *u8) == 1 { return CHJ_C_EYE_T }
  if chj_keyeq(buf, at, end, "face_required" as *u8) == 1 { return CHJ_C_FACE_REQ }
  return 0-1
127}
128func chj_conf_load(path: *u8, cf: *i64) -> i64 {
  chj_conf_defaults(cf)
  if (path as i64) == 0 { return 0 }
  let lenp: *i64 = sys_mmap(16) as *i64
  let buf: *u8 = sys_read_file(path, lenp)
  if (buf as i64) == 0 { return 0 }
  let n: i64 = lenp[0]
  var i: i64 = 0
  while i < n {
      var e: i64 = i
      var go: i64 = 1
      while go == 1 {
          if e >= n { go = 0 }
          if go == 1 { if buf[e] == (10 as u8) { go = 0 } }
          if go == 1 { e = e + 1 }
      }
      if e > i { if buf[i] != (35 as u8) {
          let slot: i64 = chj_slot_for(buf, i, e)
          if slot >= 0 {
              var p: i64 = i
              var col: i64 = 0-1
              var g2: i64 = 1
              while g2 == 1 {
                  if p >= e { g2 = 0 }
                  if g2 == 1 { if buf[p] == (61 as u8) { col = p; g2 = 0 } }
                  if g2 == 1 { p = p + 1 }
              }
              if col >= 0 {
                  var v: i64 = 0
                  var neg: i64 = 0
                  var q: i64 = col + 1
                  if q < e { if buf[q] == (45 as u8) { neg = 1; q = q + 1 } }
                  while q < e {
                      let c: i64 = buf[q] as i64
                      if c >= 48 { if c <= 57 { v = v*10 + (c-48) } }
                      q = q + 1
                  }
                  if neg == 1 { v = 0-v }
                  cf[slot] = v
              }
          }
      } }
      i = e + 1
  }
  return 0
173}
174
175func chj_luma(fb: *i64, w: i64, h: i64, luma: *i64) -> i64 {
  var q: i64 = 0
  while q < w*h {
      let px: i64 = fb[q]
      let r: i64 = px&255
      let g: i64 = (px>>8)&255
      let b: i64 = (px>>16)&255
      luma[q] = (r*299 + g*587 + b*114)/1000
      q = q + 1
  }
  return 0
186}
187
188// composition bimodality: 16px cells classed smooth/detail by mean |grad| per pixel. out[0]=smooth_permil out[1]=detail_permil
189func chj_cells(luma: *i64, w: i64, h: i64, cf: *i64, outp: *i64) -> i64 {
  let cw: i64 = w/CHJ_CELL
  let chh: i64 = h/CHJ_CELL
  var smooth: i64 = 0
  var detail: i64 = 0
  var cy: i64 = 0
  while cy < chh {
      var cx: i64 = 0
      while cx < cw {
          var e: i64 = 0
          var yy: i64 = 0
          while yy < CHJ_CELL {
              var xx: i64 = 0
              while xx < CHJ_CELL {
                  let ix: i64 = cx*CHJ_CELL + xx
                  let iy: i64 = cy*CHJ_CELL + yy
                  if ix < w-1 { if iy < h-1 {
                      let l0: i64 = luma[iy*w + ix]
                      var gx: i64 = luma[iy*w + ix + 1] - l0
                      var gy: i64 = luma[(iy+1)*w + ix] - l0
                      if gx < 0 { gx = 0-gx }
                      if gy < 0 { gy = 0-gy }
                      e = e + gx + gy
                  } }
                  xx = xx + 1
              }
              yy = yy + 1
          }
          let me: i64 = e/(CHJ_CELL*CHJ_CELL)
          if me < cf[CHJ_C_SMOOTH_T] { smooth = smooth + 1 }
          if me > cf[CHJ_C_DETAIL_T] { detail = detail + 1 }
          cx = cx + 1
      }
      cy = cy + 1
  }
  let ncell: i64 = cw*chh
  if ncell < 1 { outp[0] = 0; outp[1] = 0; return 0 }
  outp[0] = smooth*1000/ncell
  outp[1] = detail*1000/ncell
  return 0
229}
230
231func chj_palette(fb: *i64, w: i64, h: i64) -> i64 {
  let seen: *u8 = sys_mmap(CHJ_BUCKETS)
  var q: i64 = 0
  while q < w*h {
      let px: i64 = fb[q]
      let r: i64 = px&255
      let g: i64 = (px>>8)&255
      let b: i64 = (px>>16)&255
      seen[(r/16)*256 + (g/16)*16 + b/16] = 1 as u8
      q = q + 1
  }
  var pal: i64 = 0
  q = 0
  while q < CHJ_BUCKETS { if seen[q] == (1 as u8) { pal = pal + 1 } q = q + 1 }
  return pal
246}
247
248// contour coherence: permil of edge pixels on ORIENTATION-STABLE runs >= run_min. Plain run-length was
249// designed-out at gate time: dense noise is fully CONNECTED (runs grow trivially) and a patch-scramble's
250// aligned seams are long lines -- so a run only extends between neighbors in the SAME quantized gradient
251// orientation bin (4 bins). Noise dies at ~1/4 per step; real contours hold a bin over long arcs.
252// outp[0]=coherent_permil outp[1]=edge_total. returns the banded axis.
253func chj_contour(luma: *i64, w: i64, h: i64, cf: *i64, outp: *i64) -> i64 {
  let et: i64 = cf[CHJ_C_EDGE_T]
  let rm: i64 = cf[CHJ_C_RUN_MIN]
  // ★CONTOURS ARE LOW-FREQUENCY STRUCTURE AND WERE BEING MEASURED ON THE HIGH-FREQUENCY CHANNEL.
  // The orientation bin came from 1-pixel finite differences on RAW luma, so surface texture perturbs the
  // bin ALONG a silhouette and the run breaks before it reaches run_min. Measured on two independent A/B
  // pairs (the same body, untextured vs PBR-textured): coherent runs collapsed 304->13 and 644->52, so the
  // axis reported an 8.9x and 6.8x REGRESSION for landing the skin bake while composition, palette and
  // detail all improved. An axis that punishes the exact improvement it exists to reward is worse than no
  // axis at all, because its verdict is authoritative and inverted.
  // Smoothing first is also what makes the adversarial kills STRONGER, not weaker: per-pixel noise falls
  // below edge_t entirely instead of being counted and then out-competed, while a patch seam is a real
  // step edge that survives any small kernel.
  var br: i64 = rm/cf[CHJ_C_CONTOUR_BLUR_DIV]
  if br < 1 { br = 1 }
  let bh: *i64 = sys_mmap(w*h*8) as *i64
  let lb: *i64 = sys_mmap(w*h*8) as *i64
  var by: i64 = 0
  while by < h {
      var bx: i64 = 0
      while bx < w {
          var acc: i64 = 0
          var cnt: i64 = 0
          var k: i64 = 0-br
          while k <= br {
              var sx: i64 = bx+k
              if sx < 0 { sx = 0 }
              if sx > w-1 { sx = w-1 }
              acc = acc + luma[by*w+sx]
              cnt = cnt + 1
              k = k + 1
          }
          bh[by*w+bx] = acc/cnt
          bx = bx + 1
      }
      by = by + 1
  }
  by = 0
  while by < h {
      var bx2: i64 = 0
      while bx2 < w {
          var acc2: i64 = 0
          var cnt2: i64 = 0
          var k2: i64 = 0-br
          while k2 <= br {
              var sy: i64 = by+k2
              if sy < 0 { sy = 0 }
              if sy > h-1 { sy = h-1 }
              acc2 = acc2 + bh[sy*w+bx2]
              cnt2 = cnt2 + 1
              k2 = k2 + 1
          }
          lb[by*w+bx2] = acc2/cnt2
          bx2 = bx2 + 1
      }
      by = by + 1
  }
  // the horizontal pass is scratch -- free it before the edge maps allocate. Resource excellence is a
  // shipping criterion: this organ is forked once per image across a 169-render corpus, and an unfreed
  // w*h*8 buffer is 4.4 MB per 1200x460 frame carried for the rest of the run for no reason.
  sys_munmap(bh as *u8, w*h*8)
  let emap: *u8 = sys_mmap(w*h)
  let bmap: *u8 = sys_mmap(w*h)
  var etotal: i64 = 0
  var y: i64 = 0
  while y < h-1 {
      var x: i64 = 0
      while x < w-1 {
          let l0: i64 = lb[y*w+x]
          let sgx: i64 = lb[y*w+x+1] - l0
          let sgy: i64 = lb[(y+1)*w+x] - l0
          var agx: i64 = sgx
          if agx < 0 { agx = 0-agx }
          var agy: i64 = sgy
          if agy < 0 { agy = 0-agy }
          if agx+agy > et {
              emap[y*w+x] = 1 as u8
              etotal = etotal + 1
              // 8 orientation bins (sign gx, sign gy, |gx|>|gy|): 4 bins percolate through dense
              // noise (58 pct continuation over 3 neighbors, supercritical -- gate T4 caught it);
              // 8 bins = ~30 pct, subcritical, noise runs die exponentially, straight contours hold.
              var bin: i64 = 0
              if sgx < 0 { bin = bin + 4 }
              if sgy < 0 { bin = bin + 2 }
              if agx > agy { bin = bin + 1 }
              bmap[y*w+x] = bin as u8
          }
          x = x + 1
      }
      y = y + 1
  }
  var coh: i64 = 0
  let prev: *i64 = sys_mmap(w*8) as *i64
  let curr: *i64 = sys_mmap(w*8) as *i64
  let prevb: *i64 = sys_mmap(w*8) as *i64
  let currb: *i64 = sys_mmap(w*8) as *i64
  var i: i64 = 0
  while i < w { prev[i] = 0; prevb[i] = 0-1; i = i + 1 }
  y = 0
  while y < h {
      var x2: i64 = 0
      while x2 < w {
          var r: i64 = 0
          var b: i64 = 0-1
          if emap[y*w+x2] == (1 as u8) {
              b = bmap[y*w+x2] as i64
              var m: i64 = 0
              if prevb[x2] == b { m = prev[x2] }
              if x2 > 0 { if prevb[x2-1] == b { if prev[x2-1] > m { m = prev[x2-1] } } }
              if x2 < w-1 { if prevb[x2+1] == b { if prev[x2+1] > m { m = prev[x2+1] } } }
              r = m + 1
              if r >= rm { coh = coh + 1 }
          }
          curr[x2] = r
          currb[x2] = b
          x2 = x2 + 1
      }
      var x3: i64 = 0
      while x3 < w { prev[x3] = curr[x3]; prevb[x3] = currb[x3]; x3 = x3 + 1 }
      y = y + 1
  }
  let prevh: *i64 = sys_mmap(h*8) as *i64
  let currh: *i64 = sys_mmap(h*8) as *i64
  let prevhb: *i64 = sys_mmap(h*8) as *i64
  let currhb: *i64 = sys_mmap(h*8) as *i64
  i = 0
  while i < h { prevh[i] = 0; prevhb[i] = 0-1; i = i + 1 }
  var x4: i64 = 0
  while x4 < w {
      var y2: i64 = 0
      while y2 < h {
          var r2: i64 = 0
          var b2: i64 = 0-1
          if emap[y2*w+x4] == (1 as u8) {
              b2 = bmap[y2*w+x4] as i64
              var m2: i64 = 0
              if prevhb[y2] == b2 { m2 = prevh[y2] }
              if y2 > 0 { if prevhb[y2-1] == b2 { if prevh[y2-1] > m2 { m2 = prevh[y2-1] } } }
              if y2 < h-1 { if prevhb[y2+1] == b2 { if prevh[y2+1] > m2 { m2 = prevh[y2+1] } } }
              r2 = m2 + 1
              if r2 >= rm { coh = coh + 1 }
          }
          currh[y2] = r2
          currhb[y2] = b2
          y2 = y2 + 1
      }
      var y3: i64 = 0
      while y3 < h { prevh[y3] = currh[y3]; prevhb[y3] = currhb[y3]; y3 = y3 + 1 }
      x4 = x4 + 1
  }
  var perm: i64 = 0
  if etotal > 0 { perm = coh*1000/etotal }
  if etotal < w*h/400 { perm = 0 }
  outp[0] = perm
  outp[1] = etotal
  // FREE THE SCRATCH. A census over a 169-render corpus multiplies every unfreed buffer by the corpus
  // size; at ~1MP per frame this function alone held ~4.7 GB of address space for no reason, on a box
  // already sitting at 720 permil swap. Resource excellence is a shipping criterion, not tidiness.
  sys_munmap(lb as *u8, w*h*8)
  sys_munmap(emap, w*h)
  sys_munmap(bmap, w*h)
  sys_munmap(prev as *u8, w*8)
  sys_munmap(curr as *u8, w*8)
  sys_munmap(prevb as *u8, w*8)
  sys_munmap(currb as *u8, w*8)
  sys_munmap(prevh as *u8, h*8)
  sys_munmap(currh as *u8, h*8)
  sys_munmap(prevhb as *u8, h*8)
  sys_munmap(currhb as *u8, h*8)
  var axis: i64 = perm*1000/cf[CHJ_C_COH_DIV]
  if axis > 1000 { axis = 1000 }
  return axis
425}
426
427// one face scan at the current scale: center-surround compact dark blobs -> level spaced pair
428func chj_face_scan(l: *i64, w: i64, h: i64, cf: *i64, ncout: *i64) -> i64 {
  let eyet: i64 = cf[CHJ_C_EYE_T]
  // ★SCALE-COVARIANT LENGTHS. Every geometric constant below is expressed at ref_w and scaled to the
  // width actually being scanned, so the detector hunts the same FEATURE rather than the same pixel
  // count. At w == ref_w the factor is exactly 1000/1000, which is why this changes nothing at the
  // resolutions that already worked. Each result is floored at 1: a probe radius of zero reads the
  // centre pixel against itself and would make every pixel a candidate.
  // THE PYRAMID IS THE SCALE SEARCH; THE PROBE IS FIXED IN PIXELS. Scaling by the CURRENT level width
  // made probe and pyramid cancel exactly, so every level re-ran one identical scan and the search was
  // INERT. Scaling by the ORIGINAL width probes one large size at every level: measured 2026-08-15 that
  // recovered a 640px face close-up (0 -> 1000) and LOST an 800px body render (1000 -> 0). Trading one
  // false negative for another is not a fix. Fixed pixels + pyramid spans the whole size range.
  let sc: i64 = 1000
  var pf: i64 = cf[CHJ_C_PROBE_FAR]*sc/1000
  if pf < 1 { pf = 1 }
  var pd: i64 = cf[CHJ_C_PROBE_DIAG]*sc/1000
  if pd < 1 { pd = 1 }
  // the border must clear the widest probe or the surround reads outside the buffer. Derived from the
  // probe radii rather than trusted from config: a border narrower than the probe is not a tuning
  // choice, it is an out-of-bounds read.
  var bd: i64 = cf[CHJ_C_BORDER]*sc/1000
  if bd < pf { bd = pf }
  if bd < pd { bd = pd }
  var st: i64 = cf[CHJ_C_STRIDE]*sc/1000
  if st < 1 { st = 1 }
  var dr: i64 = cf[CHJ_C_DEDUP_R]*sc/1000
  if dr < 1 { dr = 1 }
  let cx: *i64 = sys_mmap(CHJ_CAND_MAX*8) as *i64
  let cy: *i64 = sys_mmap(CHJ_CAND_MAX*8) as *i64
  var nc: i64 = 0
  var y: i64 = bd
  while y < h-bd {
      var x: i64 = bd
      while x < w-bd {
          let c: i64 = l[y*w+x]
          var okc: i64 = 1
          let p1: i64 = l[y*w + x+pf]
          let p2: i64 = l[y*w + x-pf]
          let p3: i64 = l[(y+pf)*w + x]
          let p4: i64 = l[(y-pf)*w + x]
          let p5: i64 = l[(y+pd)*w + x+pd]
          let p6: i64 = l[(y+pd)*w + x-pd]
          let p7: i64 = l[(y-pd)*w + x+pd]
          let p8: i64 = l[(y-pd)*w + x-pd]
          if p1 <= c + eyet/2 { okc = 0 }
          if p2 <= c + eyet/2 { okc = 0 }
          if p3 <= c + eyet/2 { okc = 0 }
          if p4 <= c + eyet/2 { okc = 0 }
          if p5 <= c + eyet/2 { okc = 0 }
          if p6 <= c + eyet/2 { okc = 0 }
          if p7 <= c + eyet/2 { okc = 0 }
          if p8 <= c + eyet/2 { okc = 0 }
          if okc == 1 { if (p1+p2+p3+p4+p5+p6+p7+p8)/8 - c > eyet {
              var near: i64 = 0
              var k: i64 = 0
              while k < nc {
                  var ddx: i64 = cx[k]-x
                  if ddx < 0 { ddx = 0-ddx }
                  var ddy: i64 = cy[k]-y
                  if ddy < 0 { ddy = 0-ddy }
                  if ddx < dr { if ddy < dr { near = 1 } }
                  k = k + 1
              }
              if near == 0 { if nc < CHJ_CAND_MAX { cx[nc] = x; cy[nc] = y; nc = nc + 1 } }
          } }
          x = x + st
      }
      y = y + st
  }
  // report how many blob candidates this level produced, so a zero face verdict can be attributed:
  // no candidates means the centre-surround probe never fired, a nonzero count with no pair means the
  // separation window rejected them. Those are different defects with different fixes.
  ncout[0] = nc
  var i: i64 = 0
  while i < nc {
      var j: i64 = i+1
      while j < nc {
          var dyv: i64 = cy[i]-cy[j]
          if dyv < 0 { dyv = 0-dyv }
          var dxv: i64 = cx[i]-cx[j]
          if dxv < 0 { dxv = 0-dxv }
          // the separation window scales with the render for the same reason the probe does: an
          // interpupillary distance is a length on the subject, not a pixel count.
          var wdy: i64 = cf[CHJ_C_EYE_DY]*sc/1000
          if wdy < 1 { wdy = 1 }
          var wlo: i64 = cf[CHJ_C_EYE_DXMIN]*sc/1000
          if wlo < 1 { wlo = 1 }
          var whi: i64 = cf[CHJ_C_EYE_DXMAX]*sc/1000
          if whi < wlo { whi = wlo }
          if dyv <= wdy { if dxv >= wlo { if dxv <= whi {
              // ★TWO DARK BLOBS ARE NOT A FACE. "compact, dark, level, correctly spaced" is satisfied
              // trivially by a voxel landscape: measured, snap_craft.png -- a craft-world screenshot with
              // no character face in it at all -- passed this gate and scored face 1000, while an actual
              // face close-up scored 0. Between a real pair of eyes there is always lit skin, so the
              // midpoint must be LIGHTER than both blobs by the same contrast the blob test already uses.
              // eye_t is reused deliberately: one contrast threshold for one physical claim, never a
              // second number to drift away from it.
              // ONE BRIGHT PIXEL IS NOT A FACE EITHER. The single-midpoint form STILL passed a voxel
              // landscape -- snap_craft.png measured face 1000 with no character in frame -- because
              // between two dark blocks there is very often one bright pixel of sky or ground. A real
              // pair of eyes is separated by a CONTINUOUS lit bridge of skin, so sample across it at the
              // quarter, half and three-quarter points and require EVERY one lighter than BOTH blobs.
              // Three samples cost nothing and are far harder for scenery to satisfy by accident.
              let li: i64 = l[cy[i]*w+cx[i]]
              let lj: i64 = l[cy[j]*w+cx[j]]
              var bridge: i64 = 1
              var bq: i64 = 1
              while bq <= 3 {
                  let bxp: i64 = cx[i] + (cx[j]-cx[i])*bq/4
                  let byp: i64 = cy[i] + (cy[j]-cy[i])*bq/4
                  let bv: i64 = l[byp*w + bxp]
                  if bv - li <= eyet { bridge = 0 }
                  if bv - lj <= eyet { bridge = 0 }
                  bq = bq + 1
              }
              if bridge == 1 { return 1 }
          } } }
          j = j + 1
      }
      i = i + 1
  }
  return 0
550}
551
552func chj_face(luma: *i64, w: i64, h: i64, cf: *i64, diag: *i64) -> i64 {
  var cw: i64 = w
  var chh: i64 = h
  var cur: *i64 = sys_mmap(w*h*8) as *i64
  var i: i64 = 0
  while i < w*h { cur[i] = luma[i]; i = i + 1 }
  // ★THE PYRAMID RUNS TO ITS STRUCTURAL FLOOR, NOT TO AN ARBITRARY COUNT. This loop was capped at three
  // levels, so the detector only ever covered eye separations of dxmin..4*dxmax at the original scale.
  // That cap, not the acceptance window, is why the SAME mesh scored face_axis 1000 at 256x384 and 0 at
  // 512x768: the pair was resolvable, just never at a level the loop reached. The real stop is pyr_min --
  // the size below which a scan means nothing -- and it is now the only stop.
  let ncp: *i64 = sys_mmap(16) as *i64
  var done: i64 = 0
  var levels: i64 = 0
  var maxnc: i64 = 0
  while done == 0 {
      levels = levels + 1
      ncp[0] = 0
      let hit: i64 = chj_face_scan(cur, cw, chh, cf, ncp)
      if ncp[0] > maxnc { maxnc = ncp[0] }
      diag[0] = levels
      diag[1] = maxnc
      diag[2] = cw
      if hit == 1 { return 1000 }
      let nw: i64 = cw/2
      let nh: i64 = chh/2
      if nw < cf[CHJ_C_PYR_MIN] { done = 1 }
      if nh < cf[CHJ_C_PYR_MIN] { done = 1 }
      if done == 0 {
          let nxt: *i64 = sys_mmap(nw*nh*8) as *i64
          var y: i64 = 0
          while y < nh {
              var x: i64 = 0
              while x < nw {
                  nxt[y*nw+x] = (cur[(2*y)*cw + 2*x] + cur[(2*y)*cw + 2*x+1] + cur[(2*y+1)*cw + 2*x] + cur[(2*y+1)*cw + 2*x+1])/4
                  x = x + 1
              }
              y = y + 1
          }
          // the level just scanned is dead once the next is built -- free it before advancing, or a full
          // pyramid holds every level it ever visited.
          sys_munmap(cur as *u8, cw*chh*8)
          cur = nxt
          cw = nw
          chh = nh
      }
  }
  return 0
600}
601
602// the judge. out: 0 composition 1 palette_axis 2 contour_axis 3 face_axis 4 HEADLINE
603//              5 smooth_permil 6 detail_permil 7 pal_buckets 8 coherent_permil 9 edge_total
604func chj_judge(fb: *i64, w: i64, h: i64, confpath: *u8, out: *i64) -> i64 {
  let cf: *i64 = sys_mmap(CHJ_NCONF*8) as *i64
  chj_conf_load(confpath, cf)
  let luma: *i64 = sys_mmap(w*h*8) as *i64
  chj_luma(fb, w, h, luma)
  let cellout: *i64 = sys_mmap(16) as *i64
  chj_cells(luma, w, h, cf, cellout)
  let sp: i64 = cellout[0]
  let dp: i64 = cellout[1]
  var sb: i64 = sp*1000/cf[CHJ_C_SMOOTH_DIV]
  if sb > 1000 { sb = 1000 }
  var db: i64 = dp*1000/cf[CHJ_C_DETAIL_DIV]
  if db > 1000 { db = 1000 }
  var comp: i64 = sb
  if db < comp { comp = db }
  let pal: i64 = chj_palette(fb, w, h)
  var palax: i64 = pal*1000/cf[CHJ_C_PAL_DIV]
  if palax > 1000 { palax = 1000 }
  let conout: *i64 = sys_mmap(16) as *i64
  let conax: i64 = chj_contour(luma, w, h, cf, conout)
  // ALWAYS COMPUTE; SEPARATELY DECIDE WHETHER IT VOTES. Skipping the computation when the axis was
  // disabled left out[3] at its initialiser of 1000 -- A CONSTANT WEARING THE SHAPE OF A MEASUREMENT,
  // which reads as "face detected, perfectly" on every image including a landscape with nothing in it.
  // Demoting an axis out of the verdict must not also stop measuring it, or the diagnostic that justified
  // the demotion disappears at exactly the moment it is needed. The axis is now always measured and always
  // reported with its attribution; face_required decides ONLY whether it may lower the headline.
  let fdiag: *i64 = sys_mmap(32) as *i64
  fdiag[0] = 0
  fdiag[1] = 0
  fdiag[2] = 0
  let faceax: i64 = chj_face(luma, w, h, cf, fdiag)
  out[10] = fdiag[0]
  out[11] = fdiag[1]
  out[12] = fdiag[2]
  var head: i64 = comp
  if palax < head { head = palax }
  if conax < head { head = conax }
  if cf[CHJ_C_FACE_REQ] == 1 { if faceax < head { head = faceax } }
  out[0] = comp
  out[1] = palax
  out[2] = conax
  out[3] = faceax
  out[4] = head
  out[5] = sp
  out[6] = dp
  out[7] = pal
  out[8] = conout[0]
  out[9] = conout[1]
  return head
653}
nx_charjudge_lib.nx source

`nx_charjudge_lib.nx` source
