`nx_shellclose.nx` source

↩ module page · 178 lines · 6043 B
1// nx_shellclose.nx -- CLOSE a reconstructed open sheet into a WATERTIGHT SOLID by offsetting it along its
2// own normals and stitching the rim.
3//
4// WHY: a single-view reconstruction is an open sheet. nx_meshthick correctly returns -1 on it -- an open
5// surface has no opposing face, so wall thickness is UNDEFINED. Every downstream twin measurement that
6// matters for flip analysis (min wall, underbuilt flags) therefore cannot run on reconstructed geometry at
7// all. Offsetting the sheet gives a closed body those organs CAN measure.
8//
9// ⚠HONEST SCOPE, and it must travel with every number this produces: the back surface is SYNTHESISED, not
10// observed. This is a SHELL of assumed thickness, not a two-sided capture. It makes the reconstruction
11// measurable and watertight; it does NOT make the far side real. A true solid needs views from both sides.
12// license_tier: ORIGINAL
13import "nx_mesh3.nx"
14
15const SC_Q: i64 = 256
16
17// local integer sqrt (Newton). nx_render_core has rc_isqrt but this organ is mesh-only and should not drag
18// the whole rasteriser in just for one helper.
19func sc_isqrt(n: i64) -> i64 {
  if n <= 0 { return 0 }
  var x: i64 = n
  if x > 65536 { x = 65536 }
  var i: i64 = 0
  while i < 24 {
      let y: i64 = (x + n / x) / 2
      if y == x { i = 24 } else { x = y }
      i = i + 1
  }
  return x
30}
31// accumulate unit face normals per vertex, then normalise -> nrm[i*3..]
32func sc_vertex_normals(mesh: i64, nrm: *i64) -> i64 {
  let hd: *i64 = m3_hdr(mesh)
  var i: i64 = 0
  while i < hd[0] {
      nrm[i * 3 + 0] = 0
      nrm[i * 3 + 1] = 0
      nrm[i * 3 + 2] = 0
      i = i + 1
  }
  var t: i64 = 0
  while t < hd[1] {
      let tr: *i64 = m3_tri(mesh, t)
      let a: *i64 = m3_vert(mesh, tr[0])
      let b: *i64 = m3_vert(mesh, tr[1])
      let c: *i64 = m3_vert(mesh, tr[2])
      let ux: i64 = b[0] - a[0]
      let uy: i64 = b[1] - a[1]
      let uz: i64 = b[2] - a[2]
      let vx: i64 = c[0] - a[0]
      let vy: i64 = c[1] - a[1]
      let vz: i64 = c[2] - a[2]
      let nx: i64 = uy * vz - uz * vy
      let ny: i64 = uz * vx - ux * vz
      let nz: i64 = ux * vy - uy * vx
      let n2: i64 = nx * nx + ny * ny + nz * nz
      if n2 > 0 {
          let nl: i64 = sc_isqrt(n2)
          if nl > 0 {
              var k: i64 = 0
              while k < 3 {
                  let vi: i64 = tr[k]
                  nrm[vi * 3 + 0] = nrm[vi * 3 + 0] + (nx * SC_Q) / nl
                  nrm[vi * 3 + 1] = nrm[vi * 3 + 1] + (ny * SC_Q) / nl
                  nrm[vi * 3 + 2] = nrm[vi * 3 + 2] + (nz * SC_Q) / nl
                  k = k + 1
              }
          }
      }
      t = t + 1
  }
  i = 0
  while i < hd[0] {
      let sx: i64 = nrm[i * 3 + 0]
      let sy: i64 = nrm[i * 3 + 1]
      let sz: i64 = nrm[i * 3 + 2]
      let s2: i64 = sx * sx + sy * sy + sz * sz
      if s2 > 0 {
          let sl: i64 = sc_isqrt(s2)
          if sl > 0 {
              nrm[i * 3 + 0] = (sx * SC_Q) / sl
              nrm[i * 3 + 1] = (sy * SC_Q) / sl
              nrm[i * 3 + 2] = (sz * SC_Q) / sl
          }
      }
      i = i + 1
  }
  return 0
89}
90// how many triangles use the undirected edge (p,q)
91func sc_edge_uses(mesh: i64, p: i64, q: i64) -> i64 {
  let hd: *i64 = m3_hdr(mesh)
  var n: i64 = 0
  var t: i64 = 0
  while t < hd[1] {
      let tr: *i64 = m3_tri(mesh, t)
      var hits: i64 = 0
      var k: i64 = 0
      while k < 3 {
          if tr[k] == p { hits = hits + 1 }
          if tr[k] == q { hits = hits + 1 }
          k = k + 1
      }
      if hits == 2 { n = n + 1 }
      t = t + 1
  }
  return n
108}
109// count edges used by exactly ONE triangle -- 0 means the mesh is closed (watertight)
110func sc_boundary_edges(mesh: i64) -> i64 {
  let hd: *i64 = m3_hdr(mesh)
  var n: i64 = 0
  var t: i64 = 0
  while t < hd[1] {
      let tr: *i64 = m3_tri(mesh, t)
      var k: i64 = 0
      while k < 3 {
          var p: i64 = tr[k]
          var q: i64 = tr[(k + 1) % 3]
          if p < q {
              if sc_edge_uses(mesh, p, q) == 1 { n = n + 1 }
          }
          k = k + 1
      }
      t = t + 1
  }
  return n
128}
129// Close `src` into `dst`: front sheet + back sheet offset by `thick` along -normal + a stitched rim.
130// Returns the triangle count, or -1 if it would exceed the mesh capacity (REFUSE, never truncate).
131func sc_close(src: i64, dst: i64, thick: i64, nrm: *i64) -> i64 {
  let hs: *i64 = m3_hdr(src)
  let nv: i64 = hs[0]
  let nt: i64 = hs[1]
  if nv * 2 > M3_MAXV { return 0 - 1 }
  sc_vertex_normals(src, nrm)
  // front verts, then back verts (same order, so back index = front index + nv)
  var i: i64 = 0
  while i < nv {
      let v: *i64 = m3_vert(src, i)
      m3_add_vert(dst, v[0], v[1], v[2])
      i = i + 1
  }
  i = 0
  while i < nv {
      let v: *i64 = m3_vert(src, i)
      m3_add_vert(dst, v[0] - (nrm[i * 3 + 0] * thick) / SC_Q, v[1] - (nrm[i * 3 + 1] * thick) / SC_Q, v[2] - (nrm[i * 3 + 2] * thick) / SC_Q)
      i = i + 1
  }
  var out: i64 = 0
  var t: i64 = 0
  while t < nt {
      let tr: *i64 = m3_tri(src, t)
      m3_add_tri(dst, tr[0], tr[1], tr[2])
      // back face with REVERSED winding so the shell is consistently oriented outward
      m3_add_tri(dst, tr[2] + nv, tr[1] + nv, tr[0] + nv)
      out = out + 2
      t = t + 1
  }
  // rim: every boundary edge of the ORIGINAL sheet becomes a quad joining front to back
  t = 0
  while t < nt {
      let tr: *i64 = m3_tri(src, t)
      var k: i64 = 0
      while k < 3 {
          let p: i64 = tr[k]
          let q: i64 = tr[(k + 1) % 3]
          if sc_edge_uses(src, p, q) == 1 {
              m3_add_tri(dst, p, q, q + nv)
              m3_add_tri(dst, p, q + nv, p + nv)
              out = out + 2
          }
          k = k + 1
      }
      t = t + 1
  }
  return out
178}
nx_shellclose.nx source

`nx_shellclose.nx` source
