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

↩ module page · 296 lines · 14368 B
1// nx_meshprofile.nx -- ★WHERE DOES THE SURFACE STEP? The instrument that should have been built before
2// the third hypothesis (seq1472).
3//
4// Three guesses at the profile-prior banding were each built and rendered and each refuted: axial C0
5// creasing, layer superposition, part-edge divergence. That is three build-and-look cycles spent proposing
6// causes instead of one measurement locating one. This organ locates it: it reduces a mesh to its RADIUS
7// PROFILE about the vertical axis -- max radius per y band -- and reports the bands where that profile
8// JUMPS. A visible ring IS a step in this curve, so the largest jumps NAME the stations to go look at.
9//
10// Output is deliberately a SHORTLIST, not a dump: the top jumps with their per-mille stations, so two runs
11// can be compared by eye in a dozen lines instead of two hundred.
12//
13//   nx_meshprofile <in.nxmesh> [layer -1|0|1|2]
14// license_tier: ORIGINAL  expect_exit: 0  No hw writes (Rule 26).
15import "nx_syscalls.nx"
16import "nx_itoa_lib.nx"   // shared MSB-first emitter (zero-alloc)
17const MP_MAGIC_8388607: i64 = 8388607
18const MP_MAGIC_8388608: i64 = 8388608
19const MP_MAGIC_1152921504606846976: i64 = 1152921504606846976
20
21const MP_TS: i64 = 84
22const MP_NB: i64 = 128           // y bands over the mesh's own height
23const MP_TOP: i64 = 12           // jumps reported
24const MP_FAR: i64 = 2000000000
25const MP_SCALE: i64 = 1000       // read vertices at micrometre precision, as nx_meshview does
26
27func mp_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
28// MIGRATED to the shared emitter (debt 1785563586). The old body mmapped a scratch buffer
29// per call and never freed it. At PAGE granularity that is 4096B leaked PER CALL -- the
30// defect that took 28.5GB of a 36GB host in nx_ts_lumadiff (2MB input, ~3.66M calls).
31// nxi_* is MSB-first, allocates NOTHING, and emits identical bytes including the sign.
32func mp_num(v: i64) -> i64 { nxi_out(v); return 0 }
33func mp_rd32(b: *u8, o: i64) -> i64 {
  return (b[o] as i64) | ((b[o+1] as i64)<<8) | ((b[o+2] as i64)<<16) | ((b[o+3] as i64)<<24)
35}
36// IEEE-754 single -> integer scaled by `scale` (same convention nx_meshview reads with)
37func mp_f32(bits: i64, scale: i64) -> i64 {
  let sgn: i64 = (bits>>31) & 1
  let exp: i64 = (bits>>23) & 255
  var man: i64 = bits & MP_MAGIC_8388607
  if exp == 0 { return 0 }
  man = man | MP_MAGIC_8388608
  let e: i64 = exp - 127 - 23
  var v: i64 = man * scale
  if e > 0 { v = v << e } else { v = v >> (0 - e) }
  if sgn == 1 { v = 0 - v }
  return v
48}
49func mp_isqrt(v: i64) -> i64 {
  if v <= 0 { return 0 }
  var r: i64 = 0
  var b: i64 = MP_MAGIC_1152921504606846976   // ★4^30: the largest power of FOUR an i64 argument can need. The
                                     // seed MUST be >= n or the algorithm starts below its own leading
                                     // digit; 2^30 (=4^15) was too small for x*x+z*z, which reaches ~1.8e11.
  var n: i64 = v
  while b > n { b = b>>2 }
  while b > 0 {
      if n >= r + b { n = n - r - b; r = (r>>1) + b } else { r = r>>1 }
      b = b>>2
  }
  return r
62}
63
64// `layers` verb (debt 1785968584): the layer names became machine-usable but OPERATOR-INVISIBLE --
65// JSON transports mangle the raw 16-byte name fields. Print them as text, one row per layer.
66func mp_layers(path: *u8) -> i64 {
  let ln2: *i64 = sys_mmap(16) as *i64
  let b: *u8 = sys_read_file(path, ln2)
  if (b as i64) == 0 { mp_puts("{\x22error\x22:\x22cannot read mesh\x22}\n" as *u8); return 3 }
  if b[0] != (78 as u8) { mp_puts("{\x22error\x22:\x22not NXMSH2\x22}\n" as *u8); return 4 }
  let nl: i64 = mp_rd32(b, 8)
  let nt2: i64 = mp_rd32(b, 12)
  mp_puts("LAYERS n=" as *u8); mp_num(nl); mp_puts(" tris=" as *u8); mp_num(nt2); mp_puts("\n" as *u8)
  var L: i64 = 0
  while L < nl {
      let lb: i64 = 16 + L*24
      mp_puts("  " as *u8); mp_num(L); mp_puts("\t" as *u8)
      var k: i64 = 0
      var shown: i64 = 0
      while k < 16 {
          let ch: i64 = b[lb+k] as i64
          if ch >= 32 { if ch < 127 { sys_write(1, ((b as i64)+lb+k) as *u8, 1); shown = shown + 1 } }
          k = k + 1
      }
      if shown == 0 { mp_puts("(unnamed)" as *u8) }
      mp_puts("\toff=" as *u8); mp_num(mp_rd32(b, lb+16))
      mp_puts("\tcount=" as *u8); mp_num(mp_rd32(b, lb+20))
      mp_puts("\n" as *u8)
      L = L + 1
  }
  return 0
92}
93
94func main(argc: i64, argv: *i64) -> i64 {
  if argc < 2 { mp_puts("usage: nx_meshprofile <in.nxmesh> [layer -1|0|1|2] | layers <in.nxmesh>\n" as *u8); return 2 }
  let a1v: *u8 = argv[1] as *u8
  if a1v[0] == (108 as u8) { if a1v[1] == (97 as u8) { if a1v[2] == (121 as u8) { if a1v[3] == (101 as u8) { if a1v[4] == (114 as u8) { if a1v[5] == (115 as u8) { if a1v[6] == (0 as u8) {
      if argc < 3 { mp_puts("usage: nx_meshprofile layers <in.nxmesh>\n" as *u8); return 2 }
      let rcl: i64 = mp_layers(argv[2] as *u8)
      sys_exit(rcl)
      return rcl
  } } } } } } }
  var want: i64 = 0 - 1
  if argc > 2 {
      var a: i64 = 0
      let s: *u8 = argv[2] as *u8
      var i2: i64 = 0
      var neg: i64 = 0
      if s[0] == (45 as u8) { neg = 1; i2 = 1 }
      while s[i2] != (0 as u8) { a = a*10 + ((s[i2] as i64) - 48); i2 = i2 + 1 }
      if neg == 1 { a = 0 - a }
      want = a
  }
  // ★LANE (argv[3]): 0 front(+z) 1 right(+x) 2 back(-z) 3 left(-x). A SINGLE midline lane is blind to
  // anything that does not live on it -- nx_facemark learned this the expensive way (seq873/F1091: its
  // midline judge rated the best brow WORST because a brow lives laterally). Four sectors need no trig.
  var lane: i64 = 0
  if argc > 3 {
      var la: i64 = 0
      let ls: *u8 = argv[3] as *u8
      var li: i64 = 0
      while ls[li] != (0 as u8) { la = la*10 + ((ls[li] as i64) - 48); li = li + 1 }
      lane = la
  }
  let ln: *i64 = sys_mmap(16) as *i64
  let buf: *u8 = sys_read_file(argv[1] as *u8, ln)
  if (buf as i64) == 0 { mp_puts("{\x22error\x22:\x22cannot read mesh\x22}\n" as *u8); return 3 }
  if buf[0] != (78 as u8) { mp_puts("{\x22error\x22:\x22not NXMSH2\x22}\n" as *u8); return 4 }
  let nlayer: i64 = mp_rd32(buf, 8)
  let nt: i64 = mp_rd32(buf, 12)
  if nt <= 0 { mp_puts("{\x22error\x22:\x22no triangles\x22}\n" as *u8); return 5 }
  let hdr: i64 = 16 + nlayer*24
  let lay: i64 = hdr + nt*MP_TS
134
  // pass 1: bounds over the selected layer
  var lox: i64 = MP_FAR; var hix: i64 = 0-MP_FAR
  var loy: i64 = MP_FAR; var hiy: i64 = 0-MP_FAR
  var loz: i64 = MP_FAR; var hiz: i64 = 0-MP_FAR
  var kept: i64 = 0
  var t: i64 = 0
  while t < nt {
      var take: i64 = 1
      if want >= 0 { if mp_rd32(buf, lay + t*4) != want { take = 0 } }
      if take == 1 {
          kept = kept + 1
          var j: i64 = 0
          while j < 3 {
              let o: i64 = hdr + t*MP_TS + j*12
              let x: i64 = mp_f32(mp_rd32(buf,o),   MP_SCALE)
              let y: i64 = mp_f32(mp_rd32(buf,o+4), MP_SCALE)
              let z: i64 = mp_f32(mp_rd32(buf,o+8), MP_SCALE)
              if x < lox { lox = x }
              if x > hix { hix = x }
              if y < loy { loy = y }
              if y > hiy { hiy = y }
              if z < loz { loz = z }
              if z > hiz { hiz = z }
              j = j + 1
          }
      }
      t = t + 1
  }
  if kept == 0 { mp_puts("{\x22error\x22:\x22layer empty\x22}\n" as *u8); return 6 }
  let cx: i64 = (lox+hix)/2
  let cz: i64 = (loz+hiz)/2
  var hy: i64 = hiy - loy
  if hy < 1 { hy = 1 }
168
  // pass 2: max radius about the vertical axis, per y band
  let R: *i64 = sys_mmap(MP_NB*8) as *i64
  var b: i64 = 0
  while b < MP_NB { R[b] = 0; b = b + 1 }
  t = 0
  while t < nt {
      var take2: i64 = 1
      if want >= 0 { if mp_rd32(buf, lay + t*4) != want { take2 = 0 } }
      if take2 == 1 {
          var j: i64 = 0
          while j < 3 {
              let o: i64 = hdr + t*MP_TS + j*12
              let x: i64 = mp_f32(mp_rd32(buf,o),   MP_SCALE) - cx
              let y: i64 = mp_f32(mp_rd32(buf,o+4), MP_SCALE)
              let z: i64 = mp_f32(mp_rd32(buf,o+8), MP_SCALE) - cz
              var bi: i64 = (y - loy)*MP_NB/hy
              if bi < 0 { bi = 0 }
              if bi >= MP_NB { bi = MP_NB - 1 }
              let r: i64 = mp_isqrt(x*x + z*z)
              // ★★FIXED-THETA LANE, and the first version's failure is why. Max-radius-over-ALL-theta is
              // CONFOUNDED BY LIMBS: at hip and shoulder stations the arms enter and leave the band and
              // the max jumps for reasons that have nothing to do with a surface step. MEASURED: the jump
              // stations came back IDENTICAL for PROF=0 and PROF=1000 (539/554/593/609/632/648/671/718/
              // 750/773/820/828 both times) -- the signature of a metric reading ANATOMY, not a defect.
              // seq1472 asked for radius-vs-y at FIXED THETA and this is now that: a narrow sector about
              // the FRONT midline, where the torso and the arms do not overlap.
              var ax: i64 = x
              if ax < 0 { ax = 0 - ax }
              var az: i64 = z
              if az < 0 { az = 0 - az }
              var keep: i64 = 0
              if lane == 0 { if z > 0 { if ax*4 < r { keep = 1 } } }
              if lane == 1 { if x > 0 { if az*4 < r { keep = 1 } } }
              if lane == 2 { if z < 0 { if ax*4 < r { keep = 1 } } }
              if lane == 3 { if x < 0 { if az*4 < r { keep = 1 } } }
              if keep == 1 { if r > R[bi] { R[bi] = r } }
              j = j + 1
          }
      }
      t = t + 1
  }
210
  // ★THE SHORTLIST: the bands where the radius profile JUMPS. A visible ring is a step in this curve,
  // so the largest jumps name the stations. Empty bands are skipped -- a gap is not a step.
  mp_puts("{\x22organ\x22:\x22nx_meshprofile\x22,\x22layer\x22:" as *u8); mp_num(want)
  mp_puts(",\x22tris\x22:" as *u8); mp_num(kept)
  mp_puts(",\x22bands\x22:" as *u8); mp_num(MP_NB)
  mp_puts(",\x22height_um\x22:" as *u8); mp_num(hy)
  // ★DIAGNOSTIC BEFORE THE VERDICT: an empty shortlist could mean 'no steps' or 'the array never filled',
  // and those are opposite conclusions. Print the population so the output can never be read as the wrong
  // one. This is the instrumentation the empty first run needed, added instead of a fourth hypothesis.
  var nz: i64 = 0
  var rmax: i64 = 0
  var rmin: i64 = MP_FAR
  // ★WHERE, NOT JUST HOW MUCH. radius_min alone said our skull pinches to 2.5-9mm against the oracle's
  // 37.7mm floor -- a real defect, but unactionable without the station. A number with no location cannot
  // be fixed; it can only be worried about.
  var rminat: i64 = 0-1
  var rmaxat: i64 = 0-1
  b = 0
  while b < MP_NB {
      if R[b] > 0 {
          nz = nz + 1
          if R[b] > rmax { rmax = R[b]; rmaxat = b*1000/MP_NB }
          if R[b] < rmin { rmin = R[b]; rminat = b*1000/MP_NB }
      }
      b = b + 1
  }
  mp_puts("}\n  DIAG nonzero_bands " as *u8); mp_num(nz)
  mp_puts(" of " as *u8); mp_num(MP_NB)
  mp_puts("  radius_min " as *u8); mp_num(rmin)
  mp_puts(" @station " as *u8); mp_num(rminat)
  mp_puts("  radius_max " as *u8); mp_num(rmax)
  mp_puts(" @station " as *u8); mp_num(rmaxat)
  mp_puts("  mid_band_R " as *u8); mp_num(R[MP_NB/2])
  mp_puts("\n  station_permille  radius_um  jump_from_previous  (largest first)\n" as *u8)
  // ★★★CONSUME WITHOUT MUTATING THE MEASUREMENT. The consume step used to be `R[best] = R[best-1]`, which
  // overwrites the band's measured radius to erase the jump -- and that CASCADES: rewriting band N changes
  // band N-1's delta, so later passes invent jumps at radii the mesh never had, and the SAME station can be
  // reported twice with two different radii (observed live: stations 203/210/218 each appeared twice, once
  // at 67500/68529/69564 and again at a flat 48500). Only the first few entries were ever trustworthy.
  // A mark array erases the jump from the SEARCH without editing the data the report prints.
  let USED: *i64 = sys_mmap(MP_NB*8) as *i64
  b = 0
  while b < MP_NB { USED[b] = 0; b = b + 1 }
  var shown: i64 = 0
  var guard: i64 = 0
  while guard < MP_TOP {
      var best: i64 = 0 - 1
      var bestv: i64 = 0
      b = 1
      while b < MP_NB {
          if USED[b] == 0 { if R[b] > 0 { if R[b-1] > 0 {
              var d: i64 = R[b] - R[b-1]
              if d < 0 { d = 0 - d }
              if d > bestv { bestv = d; best = b }
          } } }
          b = b + 1
      }
      if best < 0 { guard = MP_TOP } else {
          mp_puts("  " as *u8); mp_num((loy + best*hy/MP_NB - loy)*1000/hy)
          mp_puts("  " as *u8); mp_num(R[best])
          mp_puts("  " as *u8); mp_num(bestv)
          mp_puts("\n" as *u8)
          USED[best] = 1             // consume the jump from the SEARCH, never from the DATA
          shown = shown + 1
          guard = guard + 1
      }
  }
  mp_puts("  jumps_shown " as *u8); mp_num(shown)
  mp_puts(" of cap " as *u8); mp_num(MP_TOP)
  mp_puts(" DECLARED\n" as *u8)
  // ★★★THE CLOSURE PROFILE: radius as per-mille of THIS mesh's OWN max, per band. Dimensionless, so two
  // meshes of different size compare directly and it transfers as a SHAPE rule with SIZE left procedural --
  // the same discipline nx_profile_fit already uses for sections. The top-12 shortlist structurally CANNOT
  // carry this: the crown defect (ours 9000um @station 960 vs the oracle's 37716 @984) is a property of the
  // whole tail of the curve, not of any single jump, so it was invisible until the curve itself was printed.
  // -1 marks an empty band, which is itself the signal for the 10 height bands we are missing vs the oracle.
  mp_puts("  closure_permille_of_max band0..127 (-1 = empty)\n " as *u8)
  b = 0
  while b < MP_NB {
      mp_puts(" " as *u8)
      if R[b] > 0 { mp_num(R[b]*1000/rmax) } else { mp_num(0-1) }
      b = b + 1
  }
  mp_puts("\n" as *u8)
  return 0
296}
nx_meshprofile.nx source

`nx_meshprofile.nx` source
