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

↩ module page · 582 lines · 35008 B
1// nx_silhouette.nx -- ★★★PHOTO -> OUTLINE PROFILE: the missing link between a reference figure and a number.
2//
3// WHY THIS EXISTS. The curvature metric reads 3D geometry, so a photograph -- which is what every reference
4// figure actually is -- could not be measured at all. That left "aim at this figure" as an instruction with no
5// arithmetic behind it. This organ closes that: a photo becomes a half-width profile, and the profile goes into
6// the SAME curvature measurement the meshes use.
7// ★★ONE CURVATURE IMPLEMENTATION, TWO SOURCES. This organ deliberately does NOT compute curvature. It emits a
8// profile; nx_curvebench measures it. A second copy of the metric living here is how a photo target and a mesh
9// score would quietly drift onto different scales and stop being comparable -- which would defeat the entire
10// point of extracting an aim point in the first place.
11//
12// ★★AND IT IS THE SAME PIECE THE TWIN LOOP NEEDS. Registration (bringing a subject and the model into one
13// frame) starts from exactly this: the subject's outline. So the beauty lane and the capture ladder turn out to
14// want one capability, which is the second time in this programme that two goals have collapsed into one rung.
15//
16// SEGMENTATION: skin classified in CHROMA, not in brightness. The classic robust rule -- skin occupies a
17// compact region in Cb/Cr almost independently of lightness -- which is why it survives the hard sun-and-shade
18// mixtures in outdoor reference photography where a brightness threshold would cut the figure in half at the
19// shadow line. ★HONEST SCOPE, stated because it decides where this may be pointed: this works on a figure
20// against a non-skin background. It is not a general matting solution, it will fail on skin-toned backgrounds,
21// sand, and tanned wood, and T3 exists to prove it at least REFUSES rather than inventing a body.
22//
23//   nx_silhouette profile <image> <out.prof> [bands]  -> half-width profile + coverage
24//   nx_silhouette selftest
25// license_tier: ORIGINAL  expect_exit: 0  No hw writes (Rule 26).
26import "nx_gate_verdict.nx"
27// ★the decoder is COMPOSED, not rewritten. A second JPEG path in this organ would be a second definition of
28// what a pixel is, and the two would disagree the first time either was improved.
29import "nx_img_bytes_to_rgb.nx"
30const SL_MAGIC_1000000000: i64 = 1000000000
31
32const SL_BANDS: i64 = 128
33const SL_PREC: i64 = 100000
34const SL_MM: i64 = 1000
35const SL_MODE: i64 = 420
36// ★SKIN IN CHROMA. Cb/Cr bounds are the standard compact skin locus; the wide Y admission is deliberate so a
37// figure lit half in sun and half in shade stays ONE figure.
38const SL_CB_LO: i64 = 77
39const SL_CB_HI: i64 = 127
40const SL_CR_LO: i64 = 133
41const SL_CR_HI: i64 = 173
42const SL_Y_LO: i64 = 40
43// ★how close to the border still counts as touching it -- a couple of pixels of vignetting or JPEG ringing
44// should not decide whether a row bled, so the test is "at the border" with a small tolerance, not "at x=0".
45const SL_EDGE: i64 = 2
46// ★the refusal line, in per-mille of figure rows. Measured: synthetic fixtures bleed 0; the over-firing
47// reference photograph bleeds ~1000. Half the rows spanning border to border is already not a segmentation.
48const SL_MAXBLEED: i64 = 500
49// a row needs this many skin pixels before it counts as figure -- one stray pixel is not a body
50const SL_MINRUN: i64 = 3
51// below this fraction of rows carrying figure, the profile is not a measurement and the organ says so
52const SL_MINCOV: i64 = 250
53
54func sl_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
55func sl_pn(v: i64) -> i64 {
  let b: *u8 = sys_mmap(32); var x: i64=v; var ng: i64=0
  if x<0 { ng=1; x=0-x }
  var i: i64=31
  if x==0 { b[i]=48 as u8; i=i-1 }
  while x>0 { b[i]=(48+x%10) as u8; x=x/10; i=i-1 }
  if ng==1 { b[i]=45 as u8; i=i-1 }
  sys_write(1,(b as i64 + i + 1) as *u8, 31-i); return 0
63}
64func sl_streq(a: *u8, b: *u8) -> i64 {
  var i: i64=0; var go: i64=1; var eq: i64=1
  while go==1 { if a[i]!=b[i] { eq=0; go=0 } else { if a[i]==(0 as u8) { go=0 } else { i=i+1 } } }
  return eq
68}
69func sl_atoi(s: *u8) -> i64 {
  var i: i64=0; var n: i64=0; var sg: i64=1
  if s[0]==(45 as u8) { sg=0-1; i=1 }
  while s[i]!=(0 as u8) { let c: i64=s[i] as i64; if c>=48 { if c<=57 { n=n*10+(c-48) } } i=i+1 }
  return n*sg
74}
75func sl_wint(b: *u8, pos: *i64, v: i64, c: i64) -> i64 {
  var x: i64=v
  if x<0 { b[pos[0]]=45 as u8; pos[0]=pos[0]+1; x=0-x }
  let t: *u8 = sys_mmap(32); var k: i64=0
  if x==0 { t[0]=48 as u8; k=1 }
  while x>0 { t[k]=(48+x%10) as u8; x=x/10; k=k+1 }
  var q: i64=k-1
  while q>=0 { b[pos[0]]=t[q]; pos[0]=pos[0]+1; q=q-1 }
  b[pos[0]]=c as u8; pos[0]=pos[0]+1
  return 0
85}
86// ★CHROMA SKIN TEST. Integer BT.601: the same transform the codec lane already uses, so a pixel called skin
87// here is called skin there too rather than by a second private definition of the same colour.
88func sl_is_skin(r: i64, g: i64, b: i64) -> i64 {
  let y: i64  = (r*299 + g*587 + b*114)/1000
  let cb: i64 = 128 + (b-y)*564/1000
  let cr: i64 = 128 + (r-y)*713/1000
  if y < SL_Y_LO { return 0 }
  if cb < SL_CB_LO { return 0 }
  if cb > SL_CB_HI { return 0 }
  if cr < SL_CR_LO { return 0 }
  if cr > SL_CR_HI { return 0 }
  // ★and the ordering rule that kills most false positives: skin is R > G > B. Foliage and water satisfy the
  // chroma box surprisingly often; they almost never satisfy the ordering as well.
  if r <= g { return 0 }
  if g <= b { return 0 }
  return 1
102}
103// scan RGB into a half-width profile. out[0..bands-1] = half-width in 1/100000 of FIGURE HEIGHT,
104// out[bands] = rows with figure, out[bands+1] = coverage per-mille
105// 2D CONNECTED COMPONENTS, run-based with union-find. MEASURED REASON THIS EXISTS: taking the first and last
106// skin pixel in a row absorbed a tan UI swatch 400px from the subject and reported the GAP as a body width
107// (914 per-mille of rows contaminated, span 435 per-mille too wide, while edge_bleed read 0 and called the
108// frame CLEAN). The obvious repair -- the LONGEST CONTIGUOUS RUN -- is also wrong: a horizontal scan across a
109// face crosses cheek, sclera, bridge, sclera, cheek, so the longest run is ONE CHEEK (166px -> 47px against a
110// 125px face, measured A/B on the same frame; that build was promoted and then reverted).
111// THE POINT: an eye does not disconnect a face, because the cheek joins around it VERTICALLY. Only 2D
112// connectivity separates a HOLE INSIDE the subject from a SECOND OBJECT BESIDE it, and no row-local rule can
113// ever do it -- which is exactly why both 1D repairs failed, in opposite directions.
114const SL_MAXRUNS: i64 = 262144
115func sl_find(p: *i64, x: i64) -> i64 {
  var r: i64 = x
  while p[r] != r { r = p[r] }
  var c: i64 = x
  while p[c] != c { let n: i64 = p[c]; p[c] = r; c = n }
  return r
121}
122// fill clo/chi with the LARGEST component's per-row extents; returns its pixel count, or negative to REFUSE.
123// A frame with more runs than the arena is REFUSED (-9), never silently truncated: a truncated labelling
124// would split the subject and report a fragment as the body, which is the failure this whole function exists
125// to end.
126func sl_ccl(rgb: *u8, w: i64, h: i64, clo: *i64, chi: *i64) -> i64 {
  let rs: *i64 = sys_mmap(SL_MAXRUNS*8) as *i64
  let re: *i64 = sys_mmap(SL_MAXRUNS*8) as *i64
  let rr: *i64 = sys_mmap(SL_MAXRUNS*8) as *i64
  let pa: *i64 = sys_mmap(SL_MAXRUNS*8) as *i64
  let rf: *i64 = sys_mmap((h+8)*8) as *i64
  let rc: *i64 = sys_mmap((h+8)*8) as *i64
  var nr: i64 = 0
  var y: i64 = 0
  while y < h {
      rf[y] = nr
      var cnt: i64 = 0
      var run: i64 = 0
      var x: i64 = 0
      while x < w {
          let o: i64 = (y*w + x)*3
          if sl_is_skin(rgb[o] as i64, rgb[o+1] as i64, rgb[o+2] as i64) == 1 { run = run + 1 } else {
              if run >= SL_MINRUN {
                  if nr >= SL_MAXRUNS { return 0-9 }
                  rs[nr] = x - run; re[nr] = x - 1; rr[nr] = y; pa[nr] = nr; nr = nr + 1; cnt = cnt + 1
              }
              run = 0
          }
          x = x + 1
      }
      if run >= SL_MINRUN {
          if nr >= SL_MAXRUNS { return 0-9 }
          rs[nr] = w - run; re[nr] = w - 1; rr[nr] = y; pa[nr] = nr; nr = nr + 1; cnt = cnt + 1
      }
      rc[y] = cnt
      y = y + 1
  }
  if nr == 0 { return 0-3 }
  // union runs in ADJACENT ROWS that overlap horizontally -- this is the vertical join that lets a cheek
  // reach around an eye and keeps one face as one object.
  y = 1
  while y < h {
      var i: i64 = rf[y]
      let ie: i64 = rf[y] + rc[y]
      while i < ie {
          var j: i64 = rf[y-1]
          let je: i64 = rf[y-1] + rc[y-1]
          while j < je {
              if rs[i] <= re[j] { if rs[j] <= re[i] {
                  let ra: i64 = sl_find(pa, i)
                  let rb: i64 = sl_find(pa, j)
                  if ra != rb { if ra < rb { pa[rb] = ra } else { pa[ra] = rb } }
              } }
              j = j + 1
          }
          i = i + 1
      }
      y = y + 1
  }
  let ar: *i64 = sys_mmap(SL_MAXRUNS*8) as *i64
  var k: i64 = 0
  while k < nr { ar[k] = 0; k = k + 1 }
  k = 0
  while k < nr { let r: i64 = sl_find(pa,k); ar[r] = ar[r] + (re[k]-rs[k]+1); k = k + 1 }
  var best: i64 = 0-1
  var bestA: i64 = 0-1
  k = 0
  while k < nr { let r: i64 = sl_find(pa,k); if ar[r] > bestA { bestA = ar[r]; best = r } k = k + 1 }
  y = 0
  while y < h { clo[y] = 0-1; chi[y] = 0-1; y = y + 1 }
  k = 0
  while k < nr {
      if sl_find(pa,k) == best {
          let yy: i64 = rr[k]
          if clo[yy] < 0 { clo[yy] = rs[k] } else { if rs[k] < clo[yy] { clo[yy] = rs[k] } }
          if re[k] > chi[yy] { chi[yy] = re[k] }
      }
      k = k + 1
  }
  return bestA
201}
202func sl_scan(rgb: *u8, w: i64, h: i64, W: *i64, bands: i64) -> i64 {
  if w <= 0 { return 0-1 }
  if h <= 0 { return 0-2 }
  let lo: *i64 = sys_mmap((h+8)*8) as *i64
  let hi: *i64 = sys_mmap((h+8)*8) as *i64
  var y: i64 = 0
  var ytop: i64 = 0-1
  var ybot: i64 = 0-1
  var rows: i64 = 0
  var bleed: i64 = 0
  // REGISTRATION: the skin bounding box in IMAGE pixels. Bands are placed in the FIGURE's frame, which is
  // what makes a photo comparable to a mesh regardless of crop -- but it also means a profile cannot be lined
  // up against any OTHER seat's reading of the same photograph, because nothing here says which image rows the
  // bands covered. Without that, a cross-seat disagreement cannot be told apart from a DEFINITIONAL mismatch,
  // and combining the two reports inconsistency that is really just two different definitions of one word.
  var gxlo: i64 = SL_MAGIC_1000000000
  var gxhi: i64 = 0-1
  // CONNECTIVITY. The scan below takes the FIRST and LAST skin pixel in a row as the figure's span, with no
  // test that the two belong to the same object. Any skin-toned pixel elsewhere in the row -- UI chrome, a
  // wooden block, sand, a second person -- is absorbed, and the reported width becomes the GAP BETWEEN TWO
  // UNRELATED THINGS. edge_bleed cannot see this: it fires only when a row reaches BOTH borders, so a
  // contaminant that stops short of the frame edge passes every existing tooth in silence.
  // Measured before it is fixed: blo/bhi carry the LONGEST CONTIGUOUS run per row, so the span-based answer
  // and the connected answer can be compared on the same frame instead of one replacing the other on faith.
  // THE FIX: per-row extents now come from 2D CONNECTED COMPONENTS. The row scan below stays, but ONLY to
  // report what was excluded -- the contamination is worth showing even once it has stopped being measured.
  let clo: *i64 = sys_mmap((h+8)*8) as *i64
  let chi: *i64 = sys_mmap((h+8)*8) as *i64
  let ccA: i64 = sl_ccl(rgb, w, h, clo, chi)
  if ccA < 0 { return ccA }
  var multirow: i64 = 0
  var spansum: i64 = 0
  var bestsum: i64 = 0
  while y < h {
      var xlo: i64 = 0-1
      var xhi: i64 = 0-1
      var run: i64 = 0
      var x: i64 = 0
      var nrun: i64 = 0
      var blen: i64 = 0
      while x < w {
          let o: i64 = (y*w + x)*3
          if sl_is_skin(rgb[o] as i64, rgb[o+1] as i64, rgb[o+2] as i64) == 1 {
              run = run + 1
              if run >= SL_MINRUN { if xlo < 0 { xlo = x - run + 1 } ; xhi = x }
          } else {
              if run >= SL_MINRUN {
                  nrun = nrun + 1
                  if run > blen { blen = run }
              }
              run = 0
          }
          x = x + 1
      }
      if run >= SL_MINRUN {
          nrun = nrun + 1
          if run > blen { blen = run }
      }
      lo[y] = clo[y]
      hi[y] = chi[y]
      if xlo >= 0 {
          if nrun > 1 { multirow = multirow + 1 }
          spansum = spansum + (xhi - xlo + 1)
          bestsum = bestsum + blen
      }
      if lo[y] >= 0 {
          rows = rows + 1
          if ytop < 0 { ytop = y }
          ybot = y
          if lo[y] < gxlo { gxlo = lo[y] }
          if hi[y] > gxhi { gxhi = hi[y] }
          // ★★★EDGE BLEED -- the measurement that tells over-firing from segmenting. A row that runs from the
          // left border to the right border has no background left in it, and a figure with no background is
          // not a figure, it is a classifier saying yes to everything. This is a PHYSICAL test, not a tuned
          // one: a photograph of a person standing in a frame must show non-skin at one side or the other.
          if xlo <= SL_EDGE { if xhi >= w-1-SL_EDGE { bleed = bleed + 1 } }
      }
      y = y + 1
  }
  if ytop < 0 { return 0-3 }
  if ybot <= ytop { return 0-4 }
  let fh: i64 = ybot - ytop + 1
  var i: i64 = 0
  while i < bands { W[i] = 0; i = i + 1 }
  // ★BANDS ARE PLACED IN THE FIGURE'S OWN FRAME, never the image frame. A photo carries arbitrary headroom
  // and crop, so measuring in image coordinates would make the same body score differently in a tighter crop.
  // Normalising by FIGURE height is what makes a photo and a mesh comparable.
  // ★★★AND THE FRAME IS GROUND-UP: band 0 is the FEET, band n-1 is the crown. That is not a preference, it is
  // the mesh's convention, and the two MUST agree or nothing downstream means anything. Image rows count
  // DOWNWARD from the top, so the natural loop index is upside down relative to a mesh, whose y counts UPWARD
  // from the floor. Emitting the natural order would have put the waist landmark -- 615/1000 of stature above
  // the GROUND, the anthropometric definition -- at 615/1000 below the CROWN, which is mid-thigh. The judge
  // would then have measured a thigh, called it a waist, and printed a perfectly plausible number.
  // ★LAW: TWO PROFILES THAT DISAGREE ABOUT WHICH END IS UP PRODUCE NO ERROR, ONLY WRONG ANSWERS. Fix it at the
  // emitter so the FILE carries the convention, not at each reader where the next reader will get it wrong.
  y = ytop
  while y <= ybot {
      if lo[y] >= 0 {
          var bi: i64 = (ybot - y) * bands / fh
          if bi < 0 { bi = 0 }
          if bi >= bands { bi = bands - 1 }
          // half-width, normalised by figure height so the result is dimensionless like the mesh path
          // lo/hi are the LARGEST CONNECTED COMPONENT's extents for this row (see sl_ccl), so this is the
          // width of one object -- not the gap between two, and not one fragment of one.
          let hw: i64 = (hi[y] - lo[y] + 1) * SL_PREC / (2*fh)
          if hw > W[bi] { W[bi] = hw }
      }
      y = y + 1
  }
  W[bands] = rows
  W[bands+1] = rows * SL_MM / h
  W[bands+2] = bleed * SL_MM / rows
  W[bands+3] = ytop
  W[bands+4] = ybot
  W[bands+5] = gxlo
  W[bands+6] = gxhi
  // how badly the span answer differs from the connected answer, on THIS frame
  W[bands+7] = multirow * SL_MM / rows
  W[bands+8] = 0
  if spansum > 0 { W[bands+8] = (spansum - bestsum) * SL_MM / spansum }
  // ★★★AND THEN REFUSE. Reporting the number is not enough -- the caller downstream reads a profile, not a
  // JSON field, and this organ's whole contract is that it refuses rather than inventing a body. A frame whose
  // rows mostly run border to border has been classified, not segmented, and every band in it is the frame
  // width rather than a body width. Measured on the licensed full-body reference: waist and hip came back
  // EXACTLY equal at the frame's own half-width, curvature exactly zero -- a perfectly confident reading of
  // the photograph's rectangle. That is the failure this refuses.
  // ⚠MEASURED, NOT ASSUMED: on the synthetic fixtures bleed is 0; on the over-firing reference it is ~1000.
  // The constant sits between two measured populations rather than being a number someone liked.
  if W[bands+2] > SL_MAXBLEED { return 0-5 }
  return fh
332}
333func sl_gate() -> i64 {
  let ctr: *i64 = gv_ctr()
  gv_head("nx_silhouette selftest -- a photograph becomes a profile, or it refuses" as *u8)
  let w: i64 = 200
  let h: i64 = 400
  let rgb: *u8 = sys_mmap(w*h*3 + 64)
  let W: *i64 = sys_mmap((SL_BANDS+16)*8) as *i64
  // ★★T1 A KNOWN RECTANGLE READS BACK AS ITSELF. Paint a skin-coloured block 100px wide over 400px of
  // height and the half-width must be 50/400 of figure height, in the profile's units. Calibration first:
  // a segmenter that finds a figure but mismeasures it is worse than one that finds nothing.
  var p: i64 = 0
  while p < w*h*3 { rgb[p] = 20 as u8; rgb[p+1] = 90 as u8; rgb[p+2] = 40 as u8; p = p + 3 }   // green field
  var yy: i64 = 0
  while yy < h {
      var xx: i64 = 50
      while xx < 150 { let o: i64 = (yy*w+xx)*3; rgb[o]=200 as u8; rgb[o+1]=150 as u8; rgb[o+2]=120 as u8; xx = xx+1 }
      yy = yy + 1
  }
  let fh1: i64 = sl_scan(rgb, w, h, W, SL_BANDS)
  let want: i64 = 100 * SL_PREC / (2*h)
  var dd: i64 = W[SL_BANDS/2] - want
  if dd < 0 { dd = 0 - dd }
  var t1: i64 = 0
  if fh1 == h { if dd <= want/50 { t1 = 1 } }
  gv_check("T1 CALIBRATED: a 100px-wide block over the full height reads back its true half-width" as *u8, t1, ctr)
  // ★★T2 REFUSES A BACKGROUND. A frame with no skin in it must return an error, not an empty-but-confident
  // profile. This is the tooth that stops the organ inventing a body out of foliage.
  var q: i64 = 0
  while q < w*h*3 { rgb[q] = 20 as u8; rgb[q+1] = 90 as u8; rgb[q+2] = 40 as u8; q = q + 3 }
  var t2: i64 = 0
  if sl_scan(rgb, w, h, W, SL_BANDS) < 0 { t2 = 1 }
  gv_check("T2 REFUSES: an all-background frame errors rather than emitting an empty profile" as *u8, t2, ctr)
  // ★★★T3 THE SHAPE SURVIVES. An hourglass-shaped skin region must come back as an hourglass -- narrow in
  // the middle, wide at the ends. Without this the organ could be finding the figure and flattening it.
  var r: i64 = 0
  while r < w*h*3 { rgb[r] = 20 as u8; rgb[r+1] = 90 as u8; rgb[r+2] = 40 as u8; r = r + 3 }
  var y2: i64 = 0
  while y2 < h {
      var half: i64 = 50
      if y2 > h/4 { if y2 < h/2 { half = 50 - 25*(y2-h/4)/(h/4) } }
      if y2 >= h/2 { if y2 < h*3/4 { half = 25 + 25*(y2-h/2)/(h/4) } }
      var x2: i64 = w/2 - half
      while x2 < w/2 + half { let o: i64 = (y2*w+x2)*3; rgb[o]=200 as u8; rgb[o+1]=150 as u8; rgb[o+2]=120 as u8; x2 = x2+1 }
      y2 = y2 + 1
  }
  sl_scan(rgb, w, h, W, SL_BANDS)
  let top: i64 = W[SL_BANDS/8]
  let mid: i64 = W[SL_BANDS/2]
  var t3: i64 = 0
  if mid > 0 { if mid < top*3/4 { t3 = 1 } }
  gv_check("T3 SHAPE SURVIVES: an hourglass region reads narrow in the middle, wide at the ends" as *u8, t3, ctr)
  // ★★T4 CROP INVARIANCE -- the property that makes a photo comparable to a mesh at all. The same figure
  // photographed with more headroom must give the same profile, because bands are placed in the FIGURE's
  // frame and normalised by FIGURE height. Measure in image coordinates instead and a tighter crop silently
  // becomes a different body.
  let h2: i64 = 600
  let rgb2: *u8 = sys_mmap(w*h2*3 + 64)
  var s: i64 = 0
  while s < w*h2*3 { rgb2[s] = 20 as u8; rgb2[s+1] = 90 as u8; rgb2[s+2] = 40 as u8; s = s + 3 }
  var y3: i64 = 100
  while y3 < 500 {
      var x3: i64 = 50
      while x3 < 150 { let o: i64 = (y3*w+x3)*3; rgb2[o]=200 as u8; rgb2[o+1]=150 as u8; rgb2[o+2]=120 as u8; x3 = x3+1 }
      y3 = y3 + 1
  }
  let W2: *i64 = sys_mmap((SL_BANDS+8)*8) as *i64
  sl_scan(rgb2, w, h2, W2, SL_BANDS)
  var d4: i64 = W2[SL_BANDS/2] - want
  if d4 < 0 { d4 = 0 - d4 }
  var t4: i64 = 0
  if d4 <= want/50 { t4 = 1 }
  gv_check("T4 CROP-INVARIANT: the same figure with extra headroom gives the same profile" as *u8, t4, ctr)
  // ★T5 COVERAGE IS REPORTED, so a figure occupying a sliver of the frame is visible as a weak measurement
  // rather than passing as a strong one.
  var t5: i64 = 0
  if W2[SL_BANDS+1] > 0 { if W2[SL_BANDS+1] < SL_MM { t5 = 1 } }
  gv_check("T5 coverage is REPORTED -- a sliver of figure cannot pass as a full-frame measurement" as *u8, t5, ctr)
  // ★T6 the chroma rule rejects the two things that most often fool a skin box: foliage and open water
  var t6: i64 = 0
  if sl_is_skin(20, 90, 40) == 0 { if sl_is_skin(40, 90, 140) == 0 { if sl_is_skin(200, 150, 120) == 1 { t6 = 1 } } }
  gv_check("T6 foliage and water are rejected, skin is accepted -- the ordering rule earns its place" as *u8, t6, ctr)
  // ★★★T7 WHICH END IS UP. Every fixture above this line is vertically SYMMETRIC -- a full-height rectangle,
  // an hourglass pinched exactly at the middle, another rectangle -- so all six passed identically whether the
  // profile ran feet-to-crown or crown-to-feet. The organ shipped inverted relative to the mesh path and SIX
  // GREEN TEETH SAID NOTHING, because not one of them could tell the difference.
  // ⚠THE FIXTURE IS THE TEST. A symmetric witness cannot testify about orientation, however many of them there
  // are, and a suite of them reads exactly like a suite that works.
  // So: a WEDGE, unmistakably wide at the image BOTTOM and narrow at the image TOP. Band 0 is defined as the
  // FEET, so band 0 must come back WIDE. Invert the emitter and this tooth goes red immediately.
  var u: i64 = 0
  while u < w*h*3 { rgb[u] = 20 as u8; rgb[u+1] = 90 as u8; rgb[u+2] = 40 as u8; u = u + 3 }
  var y4: i64 = 0
  while y4 < h {
      let half: i64 = 10 + 60*y4/h                    // 10px at the top of the image, 70px at the bottom
      var x4: i64 = w/2 - half
      while x4 < w/2 + half { let o: i64 = (y4*w+x4)*3; rgb[o]=200 as u8; rgb[o+1]=150 as u8; rgb[o+2]=120 as u8; x4 = x4+1 }
      y4 = y4 + 1
  }
  sl_scan(rgb, w, h, W, SL_BANDS)
  let foot_end: i64 = W[2]
  let head_end: i64 = W[SL_BANDS-3]
  var t7: i64 = 0
  if foot_end > head_end*2 { t7 = 1 }
  gv_check("T7 GROUND-UP: band 0 is the FEET -- a wedge wide at the image bottom reads wide at band 0, which is the mesh's convention and the only orientation that makes a photo and a body comparable" as *u8, t7, ctr)
  // ★★★T8 THE DECOY THIS GATE NEVER HAD. Every fixture above paints skin on a GREEN field, which is the one
  // background a chroma rule is guaranteed to reject -- so seven teeth said the segmenter worked, and on the
  // first real photograph it classified the entire frame as body. It returned waist EXACTLY equal to hip and
  // curvature EXACTLY zero: not a crash, not a warning, a confident measurement of the photograph's rectangle.
  // ★LAW: A GATE THAT ONLY EVER SHOWS THE EASY BACKGROUND IS MEASURING THE FIXTURE, NOT THE ORGAN. The decoy
  // has to be the thing that actually fools it in the field -- here, a warm skin-toned backdrop.
  var v: i64 = 0
  while v < w*h*3 { rgb[v] = 205 as u8; rgb[v+1] = 155 as u8; rgb[v+2] = 125 as u8; v = v + 3 }   // beige wall
  var y5: i64 = 0
  while y5 < h {
      var x5: i64 = 70
      while x5 < 130 { let o: i64 = (y5*w+x5)*3; rgb[o]=200 as u8; rgb[o+1]=150 as u8; rgb[o+2]=120 as u8; x5 = x5+1 }
      y5 = y5 + 1
  }
  var t8: i64 = 0
  if sl_scan(rgb, w, h, W, SL_BANDS) == 0-5 { t8 = 1 }
  gv_check("T8 REFUSES A SKIN-TONED BACKGROUND: a figure against a beige wall bleeds border to border and is refused, not measured -- the failure that seven green teeth missed on the first real photograph" as *u8, t8, ctr)
  // T9 TWO OBJECTS IN ONE ROW -- the fixture the first eight teeth never had. Every fixture above paints
  // exactly ONE skin object, so none of them could see the scan treating the first and last skin pixel in a
  // row as one figure. On the first real game frame (a portrait with a tan UI swatch at the left edge) 914
  // per-mille of figure rows held more than one object and the reported width was 435 per-mille too wide --
  // while edge_bleed read 0 and called that frame clean, because the contaminant stopped short of the border.
  // LAW: A CONTROL THAT CATCHES TOTAL FAILURE IS SILENT ON PARTIAL FAILURE, and the frames it rated cleanest
  // were the worst contaminated.
  var m9: i64 = 0
  while m9 < w*h*3 { rgb[m9] = 20 as u8; rgb[m9+1] = 90 as u8; rgb[m9+2] = 40 as u8; m9 = m9 + 3 }
  var y9: i64 = 0
  while y9 < h {
      var xa: i64 = 10
      while xa < 30 { let o: i64 = (y9*w+xa)*3; rgb[o]=200 as u8; rgb[o+1]=150 as u8; rgb[o+2]=120 as u8; xa = xa+1 }
      var xb: i64 = 120
      while xb < 180 { let o: i64 = (y9*w+xb)*3; rgb[o]=200 as u8; rgb[o+1]=150 as u8; rgb[o+2]=120 as u8; xb = xb+1 }
      y9 = y9 + 1
  }
  sl_scan(rgb, w, h, W, SL_BANDS)
  // the FIGURE is the 60px block; the 20px decoy sits at the left, so first-to-last reports 170px.
  // T9 asserts CONTAMINATION IS DETECTED, not that it is removed. Asserting the removed-width here would
  // have locked in the longest-run remedy that the A/B above proved wrong (one cheek instead of one face).
  // A tooth must assert the property the organ actually promises: this frame is reported as contaminated.
  var t9: i64 = 0
  if W[SL_BANDS+7] > SL_MM/2 { t9 = 1 }
  gv_check("T9 CONTAMINATION IS VISIBLE: two skin objects in one row (a tan UI swatch beside the figure) are REPORTED via multirun_rows_permil, on a frame where edge_bleed reads 0 and every other tooth is silent -- a control that catches total failure is blind to partial failure" as *u8, t9, ctr)
  // T10 CONTAMINATION IS REMOVED, not merely reported -- same fixture, now asserting the WIDTH. The figure is
  // the 60px block; first-to-last would report 170px because the 20px decoy sits at the left edge. Measured on
  // the real portrait this fixture stands for: the shoulder bands read 673px before and 328px after.
  let want10: i64 = 60 * SL_PREC / (2*h)
  var d10: i64 = W[SL_BANDS/2] - want10
  if d10 < 0 { d10 = 0 - d10 }
  var t10: i64 = 0
  if d10 <= want10/20 { t10 = 1 }
  gv_check("T10 CONTAMINATION IS REMOVED: with a tan UI swatch beside her, the profile reports the FIGURE's own width and not the gap to the decoy -- the largest connected component is the subject" as *u8, t10, ctr)
  // T11 AN INTERNAL HOLE MUST NOT SPLIT THE FIGURE -- the fixture NONE of T1..T10 had. Every earlier fixture is
  // a SOLID blob, so not one of them could see a row-local rule fragmenting a real subject: a horizontal scan
  // across a face crosses cheek, sclera, bridge, sclera, cheek. Measured on a real portrait, the longest-run
  // rule returned ONE CHEEK -- 47px against a 125px face -- and passed every solid-blob tooth while doing it.
  // 2D connectivity is what makes an eye a hole INSIDE the face instead of a wall between two objects.
  var m11: i64 = 0
  while m11 < w*h*3 { rgb[m11] = 20 as u8; rgb[m11+1] = 90 as u8; rgb[m11+2] = 40 as u8; m11 = m11 + 3 }
  var ya: i64 = 0
  while ya < h {
      var xa: i64 = 60
      while xa < 140 { let o: i64 = (ya*w+xa)*3; rgb[o]=200 as u8; rgb[o+1]=150 as u8; rgb[o+2]=120 as u8; xa = xa+1 }
      ya = ya + 1
  }
  var yh: i64 = h/3
  while yh < h/3 + 20 {
      var xh: i64 = 75
      while xh < 90 { let o: i64 = (yh*w+xh)*3; rgb[o]=20 as u8; rgb[o+1]=90 as u8; rgb[o+2]=40 as u8; xh = xh+1 }
      var xk: i64 = 110
      while xk < 125 { let o: i64 = (yh*w+xk)*3; rgb[o]=20 as u8; rgb[o+1]=90 as u8; rgb[o+2]=40 as u8; xk = xk+1 }
      yh = yh + 1
  }
  sl_scan(rgb, w, h, W, SL_BANDS)
  let want11: i64 = 80 * SL_PREC / (2*h)
  var mn11: i64 = SL_MAGIC_1000000000
  var b11: i64 = 1
  while b11 < SL_BANDS-1 { if W[b11] < mn11 { mn11 = W[b11] } b11 = b11 + 1 }
  var t11: i64 = 0
  if mn11 >= want11 - want11/10 { t11 = 1 }
  gv_check("T11 AN INTERNAL HOLE DOES NOT SPLIT THE FIGURE: a blob with two non-skin eyes punched through it still measures its FULL width in EVERY band -- a row-local rule reports the widest fragment instead, and every solid-blob fixture is blind to the difference" as *u8, t11, ctr)
  return gv_verdict("SILHOUETTE-GATE" as *u8, ctr, "photo to profile; figure-framed, ground-up; refuses a background; EXCLUDES contaminating objects by 2D connected components and still reports what it excluded" as *u8)
518}
519func main(argc: i64, argv: *i64) -> i64 {
  if argc >= 2 {
      if sl_streq(argv[1] as *u8, "selftest" as *u8) == 1 { return sl_gate() }
      if sl_streq(argv[1] as *u8, "profile" as *u8) == 1 {
          if argc < 4 { sl_puts("{\x22error\x22:\x22usage: nx_silhouette profile <image> <out.prof> [bands]\x22}\n" as *u8); return 2 }
          var bands: i64 = SL_BANDS
          if argc > 4 { bands = sl_atoi(argv[4] as *u8) }
          let szp: *i64 = sys_mmap(16) as *i64
          let raw: *u8 = sys_read_file(argv[2] as *u8, szp)
          if (raw as i64) == 0 { sl_puts("{\x22error\x22:\x22image unreadable\x22}\n" as *u8); return 3 }
          let wh: *i64 = sys_mmap(32) as *i64
          let rgb: *u8 = nx_img_bytes_to_rgb(raw, szp[0], wh)
          if (rgb as i64) == 0 { sl_puts("{\x22error\x22:\x22image not decodable to RGB\x22}\n" as *u8); return 4 }
          let W: *i64 = sys_mmap((bands+16)*8) as *i64
          let fh: i64 = sl_scan(rgb, wh[0], wh[1], W, bands)
          if fh < 0 {
              sl_puts("{\x22organ\x22:\x22nx_silhouette\x22,\x22verdict\x22:\x22REFUSED\x22,\x22rc\x22:" as *u8); sl_pn(fh)
              if fh == 0-5 {
                  sl_puts(",\x22why\x22:\x22EDGE BLEED -- most rows run border to border, so there is no background left to segment against. The skin rule is matching the scene, not the subject: a warm wall, sand, wood or a skin-toned backdrop all pass a chroma test. Any profile from this frame would be the FRAME's width in every band, which reads as a perfectly confident body with zero curvature.\x22" as *u8)
                  sl_puts(",\x22fix\x22:\x22use a frame with visible non-skin background at one side, or segment with something stronger than a chroma rule\x22}\n" as *u8)
              } else {
                  sl_puts(",\x22why\x22:\x22no figure found -- the organ reports nothing rather than a profile it did not measure\x22}\n" as *u8)
              }
              return 5
          }
          // write the profile for nx_curvebench to measure. ONE curvature implementation, two sources.
          let buf: *u8 = sys_mmap(bands*16 + 256)
          let pos: *i64 = sys_mmap(16) as *i64
          pos[0] = 0
          var i: i64 = 0
          while i < bands { sl_wint(buf, pos, W[i], 10); i = i + 1 }
          let fd: i64 = sys_openat_wr(argv[3] as *u8, SL_MODE)
          if fd < 0 { sl_puts("{\x22error\x22:\x22cannot write profile\x22}\n" as *u8); return 6 }
          sys_write(fd, buf, pos[0])
          sys_close(fd)
          sl_puts("{\x22organ\x22:\x22nx_silhouette\x22,\x22v\x22:1" as *u8)
          sl_puts(",\x22width\x22:" as *u8); sl_pn(wh[0])
          sl_puts(",\x22height\x22:" as *u8); sl_pn(wh[1])
          sl_puts(",\x22figure_height_px\x22:" as *u8); sl_pn(fh)
          sl_puts(",\x22figure_rows\x22:" as *u8); sl_pn(W[bands])
          sl_puts(",\x22coverage_permil\x22:" as *u8); sl_pn(W[bands+1])
          sl_puts(",\x22edge_bleed_permil\x22:" as *u8); sl_pn(W[bands+2])
          sl_puts(",\x22bands\x22:" as *u8); sl_pn(bands)
          // the skin bbox in IMAGE pixels, so another seat can line ITS reading up against these bands
          // instead of guessing which rows they covered. Band b spans image rows measured from skin_y1
          // upward: y = skin_y1 - b*(skin_y1-skin_y0+1)/bands. A seat that cannot be registered cannot be
          // combined, and combining it anyway is how a definitional gap gets reported as a disagreement.
          sl_puts(",\x22skin_y0\x22:" as *u8); sl_pn(W[bands+3])
          sl_puts(",\x22skin_y1\x22:" as *u8); sl_pn(W[bands+4])
          sl_puts(",\x22skin_x0\x22:" as *u8); sl_pn(W[bands+5])
          sl_puts(",\x22skin_x1\x22:" as *u8); sl_pn(W[bands+6])
          // CONTAMINATION CONTROL: what fraction of figure rows contain more than one skin object, and how
          // much wider the first-to-last span is than the largest single connected run. Both zero on a clean
          // frame; a large second number means the profile is the distance between unrelated objects.
          sl_puts(",\x22multirun_rows_permil\x22:" as *u8); sl_pn(W[bands+7])
          sl_puts(",\x22span_over_connected_permil\x22:" as *u8); sl_pn(W[bands+8])
          sl_puts(",\x22method\x22:\x22skin classified in CHROMA (Cb/Cr locus plus the R>G>B ordering rule), so a figure lit half in sun and half in shade stays one figure where a brightness threshold would cut it at the shadow line. Bands are placed in the FIGURE's frame and normalised by FIGURE height, which is what makes a photo comparable to a mesh regardless of crop.\x22" as *u8)
          sl_puts(",\x22honest_scope\x22:\x22this is not general matting. It works on a figure against a NON-SKIN background and fails on skin-toned backdrops, sand and tanned wood -- that limit was written here as prose from the first version, and prose did not stop 74 photographs being turned into 74 confident numbers. It is now a CONTROL: edge_bleed_permil counts rows running border to border, and the organ REFUSES above the measured line instead of reporting the frame's own width as a body. A caveat a caller can ignore is not a limit.\x22}\n" as *u8)
          return 0
      }
  }
  sl_puts("{\x22organ\x22:\x22nx_silhouette\x22,\x22usage\x22:\x22nx_silhouette profile <image> <out.prof> [bands] | nx_silhouette selftest\x22}\n" as *u8)
  return 0
582}
nx_silhouette.nx source

`nx_silhouette.nx` source
