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

↩ module page · 424 lines · 13593 B
1// nx_explodelab_twinbake.nx -- BAKE THE ENGINEERING TWIN into the /explodelab panel data. Runs the SAME gated
2// composed pipeline as nx_cadtwin_report_gate (step_parse -> cr_find_parts -> per-part tess2 planar + nurbs
3// round -> cr_weld -> meshthick min-wall + meshseg3d shells + partid shape class + unitconv dual-dimension +
4// assemseq teardown rank) on the real as1 STEP file, then EMITS every measured number as PRE-FORMATTED card
5// text to knowledge/explodelab_twin.txt. The viewer's JS only DISPLAYS these strings (physlab no-JS-logic
6// law): every value is computed by a sovereign gated organ at bake time, never by the browser.
7// Line grammar (pipe-delimited, '#' emitted as char 35 -- nx literals cannot carry it):
8//   #TWIN|<part-name>          starts a card
9//   #F|<label>|<value>         one field row of the current card
10// expect_exit: 0  license_tier: ORIGINAL
11import "nx_cadtwin_report.nx"
12import "nx_step_write.nx"
13const K_MAGIC_524288: i64 = 524288
14const K_MAGIC_8192: i64 = 8192
15const K_MAGIC_4096: i64 = 4096
16const K_MAGIC_1024: i64 = 1024
17const K_MAGIC_20480: i64 = 20480
18const K_MAGIC_2048: i64 = 2048
19const K_MAGIC_65536: i64 = 65536
20const K_MAGIC_262144: i64 = 262144
21const K_MAGIC_4194304: i64 = 4194304
22
23// fx256 -> "N.NN" appended to the string builder
24func tb_mm2(b: *i64, v: i64) -> i64 {
  var a: i64 = v
  if a < 0 {
      swb_c(b, 45)
      a = 0 - a
  }
  let cents: i64 = (a * 100 + 128) / 256
  swb_n(b, cents / 100)
  swb_c(b, 46)
  let r: i64 = cents % 100
  if r < 10 { swb_c(b, 48) }
  swb_n(b, r)
  return 0
37}
38
39// "#F|<label>|"  -- opens a field row
40func tb_field(b: *i64, label: *u8) -> i64 {
  swb_c(b, 35)
  swb_s(b, "F|" as *u8)
  swb_s(b, label)
  swb_c(b, 124)
  return 0
46}
47
48// append the PRODUCT name (arg-0 single-quoted string) to the builder
49func tb_pname(st: *i64, prodidx: i64, out2: *i64, b: *i64) -> i64 {
  let ok: i64 = sp_arg_span(st, prodidx, 0, out2)
  if ok == 0 {
      swb_c(b, 63)
      return 0
  }
  let buf: *u8 = st[0] as *u8
  var v: i64 = out2[0]
  let e: i64 = out2[0] + out2[1]
  var sk: i64 = 1
  while sk == 1 {
      if v < e {
          if sp_isspace(buf[v] as i64) == 1 { v = v + 1 } else { sk = 0 }
      } else { sk = 0 }
  }
  if v >= e { return 0 }
  if buf[v] != (39 as u8) { return 0 }
  let s0: i64 = v + 1
  var w: i64 = s0
  var go: i64 = 1
  while go == 1 {
      if w < e {
          if buf[w] == (39 as u8) { go = 0 } else { w = w + 1 }
      } else { go = 0 }
  }
  var k: i64 = s0
  while k < w {
      swb_c(b, buf[k] as i64)
      k = k + 1
  }
  return 0
80}
81
82func main() -> i64 {
  sp_puts("=== nx_explodelab_twinbake -- bake measured engineering truth into the /explodelab card data ===\n" as *u8)
  let buf: *u8 = sys_mmap(K_MAGIC_4194304)
  let aid: *i64 = sys_mmap(K_MAGIC_524288) as *i64
  let anm: *i64 = sys_mmap(K_MAGIC_524288) as *i64
  let anl: *i64 = sys_mmap(K_MAGIC_524288) as *i64
  let aao: *i64 = sys_mmap(K_MAGIC_524288) as *i64
  let aal: *i64 = sys_mmap(K_MAGIC_524288) as *i64
  let st: *i64 = sys_mmap(256) as *i64
  let n: i64 = sp_read_file("knowledge/fetched/step_as1.stp" as *u8, buf, K_MAGIC_4194304)
  if n <= 0 {
      sp_puts("MISSING knowledge/fetched/step_as1.stp\nRED\n" as *u8)
      return 1
  }
  sp_init(st, buf, n, aid, anm, anl, aao, aal)
  let cnt: i64 = sp_scan(st)
  let out2: *i64 = sys_mmap(16) as *i64
99
  // ---- organ contexts (identical wiring to nx_cadtwin_report_gate)
  let tt: *i64 = sys_mmap(128) as *i64
  let cp: *i64 = sys_mmap(128) as *i64
  var z: i64 = 0
  while z < 16 {
      cp[z] = 0
      z = z + 1
  }
  tt[0] = st as i64
  tt[2] = cp as i64
  tt[3] = sys_mmap(768) as i64
  tt[4] = 0
  tt[5] = sys_mmap(K_MAGIC_8192) as i64
  tt[6] = sys_mmap(K_MAGIC_4096) as i64
  tt[7] = sys_mmap(128) as i64
  tt[8] = sys_mmap(16) as i64
  tt[9] = 0
  let t2: *i64 = sys_mmap(128) as *i64
  t2[0] = st as i64
  t2[1] = cp as i64
  t2[2] = sys_mmap(32) as i64
  t2[3] = sys_mmap(960) as i64
  t2[4] = sys_mmap(K_MAGIC_1024) as i64
  t2[5] = sys_mmap(128) as i64
  t2[6] = sys_mmap(512) as i64
  t2[7] = sys_mmap(256) as i64
  t2[8] = sys_mmap(K_MAGIC_8192) as i64
  t2[9] = sys_mmap(128) as i64
  t2[10] = sys_mmap(768) as i64
  t2[11] = sys_mmap(128) as i64
  t2[12] = sys_mmap(256) as i64
  let slab: *i64 = sys_mmap(K_MAGIC_20480) as *i64
  let nt: *i64 = sys_mmap(128) as *i64
  let c2: *i64 = sys_mmap(128) as *i64
  z = 0
  while z < 16 {
      c2[z] = 0
      z = z + 1
  }
  nt[0] = st as i64
  nt[2] = c2 as i64
  nt[3] = sys_mmap(256) as i64
  nt[4] = sys_mmap(64) as i64
  nt[5] = sys_mmap(16) as i64
  nt[6] = sys_mmap(128) as i64
  nt[7] = sys_mmap(128) as i64
  // units registry -- dual-dimensioning is the anti-JPL doctrine
  let u: *i64 = sys_mmap(64) as *i64
  ur_init(u, 64)
  ur_std(u)
  let iFX: i64 = ur_find(u, "fx256mm" as *u8)
  let iTHOU: i64 = ur_find(u, "thou" as *u8)
  let uout: *i64 = sys_mmap(16) as *i64
  // teardown order (nx_assemseq)
  let pe: *i64 = sys_mmap(K_MAGIC_2048) as *i64
  let ce: *i64 = sys_mmap(K_MAGIC_2048) as *i64
  let en: i64 = sp_nauo_collect(st, pe, ce, 256)
  let apd: *i64 = sys_mmap(K_MAGIC_2048) as *i64
  let npd: i64 = asq_collect_pds(pe, ce, en, apd)
  let rootpd: i64 = asq_root(pe, ce, en)
  let depth: *i64 = sys_mmap(K_MAGIC_2048) as *i64
  asq_depths(apd, npd, pe, ce, en, rootpd, depth)
  let order: *i64 = sys_mmap(K_MAGIC_2048) as *i64
  let no: i64 = asq_order(depth, npd, order)
164
  // ---- parts, attributed from the FILE's own semantics
  let pdid: *i64 = sys_mmap(128) as *i64
  let prodidx: *i64 = sys_mmap(128) as *i64
  let shellidx: *i64 = sys_mmap(128) as *i64
  let np: i64 = cr_find_parts(st, pdid, prodidx, shellidx)
  sp_puts("entities=" as *u8)
  sp_putn(cnt)
  sp_puts("  parts=" as *u8)
  sp_putn(np)
  sp_puts("  teardown steps=" as *u8)
  sp_putn(no)
  sp_puts("\n" as *u8)
177
  let b: *i64 = sys_mmap(64) as *i64
  swb_init(b, K_MAGIC_262144)
  let out4: *i64 = sys_mmap(32) as *i64
  let labels: *i64 = sys_mmap(K_MAGIC_65536) as *i64
  let desc: *i64 = sys_mmap(16) as *i64
  var sumfaces: i64 = 0
  var sumtess: i64 = 0
  var sumtris: i64 = 0
  var sumverts: i64 = 0
  var thinnest: i64 = 0 - 1
  var cards: i64 = 0
189
  var pi: i64 = 0
  while pi < np {
      let mesh: i64 = sys_mmap(m3_bytes()) as i64
      m3_init(mesh)
      tt[1] = mesh
      nt[1] = mesh
      cr_tess_part(tt, nt, t2, slab, shellidx[pi], out4)
      sumfaces = sumfaces + out4[0]
      sumtess = sumtess + out4[1]
      let h: *i64 = m3_hdr(mesh)
      let weldv: i64 = cr_weld(mesh)
      let tria: i64 = h[1]
      sumverts = sumverts + weldv
      sumtris = sumtris + tria
      pid_descriptor(mesh, desc)
      let segk: i64 = ms_segment(mesh, 0 - 300, labels)
      // min wall over faces (ray-cast, Zeiss/GOM method); misses counted honestly
      var minw: i64 = 0 - 1
      var miss: i64 = 0
      var f: i64 = 0
      while f < h[1] {
          let th: i64 = mtk_face_thickness(mesh, f)
          if th > 0 {
              if minw < 0 { minw = th } else {
                  if th < minw { minw = th }
              }
          } else { miss = miss + 1 }
          f = f + 1
      }
      if minw > 0 {
          if thinnest < 0 { thinnest = minw } else {
              if minw < thinnest { thinnest = minw }
          }
      }
      // bbox
      var mnx: i64 = 0
      var mxx: i64 = 0
      var mny: i64 = 0
      var mxy: i64 = 0
      var mnz: i64 = 0
      var mxz: i64 = 0
      if h[0] > 0 {
          let v0: *i64 = m3_vert(mesh, 0)
          mnx = v0[0]
          mxx = v0[0]
          mny = v0[1]
          mxy = v0[1]
          mnz = v0[2]
          mxz = v0[2]
          var vi: i64 = 1
          while vi < h[0] {
              let v: *i64 = m3_vert(mesh, vi)
              if v[0] < mnx { mnx = v[0] }
              if v[0] > mxx { mxx = v[0] }
              if v[1] < mny { mny = v[1] }
              if v[1] > mxy { mxy = v[1] }
              if v[2] < mnz { mnz = v[2] }
              if v[2] > mxz { mxz = v[2] }
              vi = vi + 1
          }
      }
      var ext: i64 = mxx - mnx
      if mxy - mny > ext { ext = mxy - mny }
      if mxz - mnz > ext { ext = mxz - mnz }
      ur_conv(u, ext, iFX, iTHOU, uout)
      let extthou: i64 = uout[0]
      var wallthou: i64 = 0
      if minw > 0 {
          ur_conv(u, minw, iFX, iTHOU, uout)
          wallthou = uout[0]
      }
      // teardown rank, joined by PD id
      var rank: i64 = 0 - 1
      var oi: i64 = 0
      while oi < no {
          if apd[order[oi]] == pdid[pi] { rank = oi }
          oi = oi + 1
      }
268
      // ---- emit the card
      swb_c(b, 35)
      swb_s(b, "TWIN|" as *u8)
      tb_pname(st, prodidx[pi], out2, b)
      swb_c(b, 10)
274
      tb_field(b, "Bounding box" as *u8)
      tb_mm2(b, mxx - mnx)
      swb_s(b, " x " as *u8)
      tb_mm2(b, mxy - mny)
      swb_s(b, " x " as *u8)
      tb_mm2(b, mxz - mnz)
      swb_s(b, " mm" as *u8)
      swb_c(b, 10)
283
      tb_field(b, "Max extent" as *u8)
      tb_mm2(b, ext)
      swb_s(b, " mm  /  " as *u8)
      swb_n(b, extthou)
      swb_s(b, " thou" as *u8)
      swb_c(b, 10)
290
      tb_field(b, "Min wall" as *u8)
      if minw > 0 {
          tb_mm2(b, minw)
          swb_s(b, " mm  /  " as *u8)
          swb_n(b, wallthou)
          swb_s(b, " thou" as *u8)
      } else {
          swb_s(b, "not measurable (open mesh)" as *u8)
      }
      swb_c(b, 10)
301
      tb_field(b, "Tessellation" as *u8)
      swb_n(b, out4[1])
      swb_s(b, " / " as *u8)
      swb_n(b, out4[0])
      swb_s(b, " faces  (" as *u8)
      swb_n(b, out4[2])
      swb_s(b, " planar, " as *u8)
      swb_n(b, out4[3])
      swb_s(b, " NURBS)" as *u8)
      swb_c(b, 10)
312
      tb_field(b, "Mesh" as *u8)
      swb_n(b, weldv)
      swb_s(b, " verts, " as *u8)
      swb_n(b, tria)
      swb_s(b, " tris, " as *u8)
      swb_n(b, segk)
      swb_s(b, " shells" as *u8)
      swb_c(b, 10)
321
      tb_field(b, "Thickness misses" as *u8)
      swb_n(b, miss)
      swb_s(b, " of " as *u8)
      swb_n(b, tria)
      swb_s(b, " triangles" as *u8)
      swb_c(b, 10)
328
      // reliable shape signal: extent ratio from the bbox (dimensional truth, no sampling bias)
      var mnext: i64 = mxx - mnx
      if mxy - mny < mnext { mnext = mxy - mny }
      if mxz - mnz < mnext { mnext = mxz - mnz }
      tb_field(b, "Extent ratio" as *u8)
      swb_s(b, "min:max = " as *u8)
      if ext > 0 { swb_n(b, (mnext * 1000) / ext) } else { swb_n(b, 0) }
      swb_s(b, " : 1000" as *u8)
      swb_c(b, 10)
338
      // HONEST: the covariance descriptor is VERTEX-weighted, so on hole-rich parts it describes the
      // vertex cloud (hole tubes carry most verts) rather than the outline -- the bbox above is the
      // dimensional truth. Stated on every card so the number is never read as more than it is.
      tb_field(b, "Shape descriptor" as *u8)
      swb_n(b, desc[0])
      swb_s(b, ", " as *u8)
      swb_n(b, desc[1])
      swb_s(b, " permille -- vertex-covariance, sampling-weighted" as *u8)
      swb_c(b, 10)
348
      tb_field(b, "Teardown" as *u8)
      swb_s(b, "step " as *u8)
      swb_n(b, rank + 1)
      swb_s(b, " of " as *u8)
      swb_n(b, no)
      swb_c(b, 10)
355
      tb_field(b, "Source" as *u8)
      swb_s(b, "as1.stp  ISO-10303-21  units mm declared in file" as *u8)
      swb_c(b, 10)
359
      cards = cards + 1
      pi = pi + 1
  }
363
  // ---- assembly-level card
  swb_c(b, 35)
  swb_s(b, "TWIN|_assembly" as *u8)
  swb_c(b, 10)
  tb_field(b, "Solid parts" as *u8)
  swb_n(b, np)
  swb_s(b, " attributed from file semantics" as *u8)
  swb_c(b, 10)
  tb_field(b, "Face coverage" as *u8)
  swb_n(b, sumtess)
  swb_s(b, " / " as *u8)
  swb_n(b, sumfaces)
  swb_s(b, " tessellated" as *u8)
  swb_c(b, 10)
  tb_field(b, "Total mesh" as *u8)
  swb_n(b, sumverts)
  swb_s(b, " verts, " as *u8)
  swb_n(b, sumtris)
  swb_s(b, " tris" as *u8)
  swb_c(b, 10)
  tb_field(b, "Thinnest wall" as *u8)
  tb_mm2(b, thinnest)
  swb_s(b, " mm across all parts" as *u8)
  swb_c(b, 10)
  tb_field(b, "STEP entities" as *u8)
  swb_n(b, cnt)
  swb_c(b, 10)
  cards = cards + 1
392
  let fd: i64 = sys_openat_wr("knowledge/explodelab_twin.txt" as *u8, 420)
  if fd < 0 {
      sp_puts("open knowledge/explodelab_twin.txt failed\nRED\n" as *u8)
      return 1
  }
  sys_write(fd, b[0] as *u8, b[1])
  sys_close(fd)
400
  sp_puts("cards=" as *u8)
  sp_putn(cards)
  sp_puts(" coverage=" as *u8)
  sp_putn(sumtess)
  sp_puts("/" as *u8)
  sp_putn(sumfaces)
  sp_puts(" verts=" as *u8)
  sp_putn(sumverts)
  sp_puts(" tris=" as *u8)
  sp_putn(sumtris)
  sp_puts(" thinnest=" as *u8)
  sp_putn(thinnest)
  sp_puts("fx  bytes=" as *u8)
  sp_putn(b[1])
  sp_puts("\n" as *u8)
  if cards == np + 1 {
      if sumtess == sumfaces {
          sp_puts("GREEN -- engineering twin baked to knowledge/explodelab_twin.txt\n" as *u8)
          return 0
      }
  }
  sp_puts("RED -- incomplete bake\n" as *u8)
  return 1
424}
nx_explodelab_twinbake.nx source

`nx_explodelab_twinbake.nx` source
