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

↩ module page · 587 lines · 24847 B
1// nx_garment_lib.nx -- SPATIALLY-COHERENT GARMENT MASK: replaces the rectangle that left a visible seam.
2//
3// THE MEASURED PROBLEM. A hue-only mask for a yellow dress also caught the model's FACE, because skin
4// and warm fabric are genuinely close in hue -- so no hue tolerance can separate them without either
5// losing the dress or taking the face. A rectangle "fixed" it only by brute force, and left a seam.
6//
7// THE PRINCIPLED SEPARATOR IS SPATIAL COHERENCE, NOT A TIGHTER THRESHOLD. A garment is ONE LARGE
8// CONTIGUOUS REGION. Skin is a different region that merely resembles it in colour. So: build the
9// colour-candidate set, label 8-connected components, and keep the LARGEST -- the dress survives, the
10// face falls away as a separate component, and the boundary follows the actual fabric edge instead of
11// an invented rectangle. No tuned constant decides which is which; the geometry does.
12//
13// Composes nx_img_segment's proven flood-fill labeller (ink=0/paper=255 convention) -- zero new
14// component-labelling maths -- and nx_editjudge_lib's hue/sat primitives, so ONE definition of "this
15// pixel is that colour" governs the candidate set here and the judging elsewhere.
16// license_tier: ORIGINAL
17import "nx_editjudge_lib.nx"
18import "nx_img_segment.nx"
19import "nx_color_v2.nx"
20
21const GM_MAXCOMPS: i64 = 20000   // generous: a noisy candidate set fragments; seg_components bails past this
22
23// ⚠MEASURED, AND IT REFUTED THE FIRST DESIGN: 8-connected labelling alone does NOT separate a garment
24// from skin, because they TOUCH at the neck and chest -- the flood fill walks straight across the
25// boundary and returns one blob (largest component 475336 of 495207 candidates; the face stayed green).
26// Spatial coherence cannot separate regions that are physically adjacent. The discriminator that DOES
27// survive contact is SATURATION: dyed fabric is far more saturated than skin at the same hue. So the
28// saturation floor is a PARAMETER here, swept and chosen by measurement, never a constant tuned by eye.
29func gm_candidate_mask(rgb: *u8, npix: i64, hue: i64, sat_min: i64, out_bin: *u8) -> i64 {
  var n: i64 = 0
  var i: i64 = 0
  while i < npix {
      let r: i64 = rgb[i*3] as i64
      let g: i64 = rgb[i*3+1] as i64
      let b: i64 = rgb[i*3+2] as i64
      out_bin[i] = (255 as u8)
      if ej_sat(r, g, b) >= sat_min {
          if ej_hue_dist(ej_hue(r, g, b), hue) <= EJ_HUE_TOL {
              out_bin[i] = (0 as u8)
              n = n + 1
          }
      }
      i = i + 1
  }
  return n
46}
47
48// ★THE DISCRIMINATOR THAT ACTUALLY SEPARATES THEM (F1092 rung 3).
49// Two attempts failed for the same reason: they tried to define the GARMENT, and skin and warm fabric
50// are genuinely inseparable in hue. Raising the saturation floor spared the face but also threw away
51// the garment's own shadowed folds (compliance fell to 602); connected components merged them because
52// they physically TOUCH at the neck.
53// ★INVERT THE PROBLEM: do not define the garment -- define SKIN, which is far better characterised than
54// "fabric" and is stable across people. Kovac's published classifier (Y>80, 85<Cb<135, 135<Cr<180) does
55// it in YCbCr CHROMA space -- a DIFFERENT space from the hue that failed -- so it separates precisely
56// where a hue threshold cannot. Garment = the right hue, saturated enough, AND NOT SKIN.
57// This composes nx_color_v2's existing classifier; no skin-detection maths is written here.
58func gm_candidate_mask_noskin(rgb: *u8, npix: i64, hue: i64, sat_min: i64, out_bin: *u8) -> i64 {
  var n: i64 = 0
  var i: i64 = 0
  while i < npix {
      let r: i64 = rgb[i*3] as i64
      let g: i64 = rgb[i*3+1] as i64
      let b: i64 = rgb[i*3+2] as i64
      out_bin[i] = (255 as u8)
      if nx_color_kovac_skin_pixel(r, g, b) == 0 {
          if ej_sat(r, g, b) >= sat_min {
              if ej_hue_dist(ej_hue(r, g, b), hue) <= EJ_HUE_TOL {
                  out_bin[i] = (0 as u8)
                  n = n + 1
              }
          }
      }
      i = i + 1
  }
  return n
77}
78
79// ★MULTI-MODAL MASK (F1141) -- the last thing standing between this and patterned fabric.
80// A single hue anchor stops describing the object the moment the garment has more than one tone: the
81// second tone is not flattened, it is NEVER SELECTED, which is why changing the paint operation alone
82// measured as a no-op. The fix has to be in the SELECTION.
83//
84// THE METHOD, and why it is two steps rather than one:
85//   1. the hue-anchored skin-aware core answers WHERE the garment is (a spatial region we trust);
86//   2. a hue HISTOGRAM over that region answers WHAT COLOURS it actually contains.
87//
88// ⚠⚠MEASURED AND CURRENTLY A REGRESSION -- EXPERIMENTAL, NOT THE DEFAULT. On the solid reference this
89// grades 371 against the skin-aware champion's 620: compliance 1000 with footprint 629, which is the
90// exact signature of "recoloured the face too". ROOT CAUSE: step 2 histograms the CORE'S BOUNDING BOX,
91// and that rectangle spans background as well as garment, so BACKGROUND hues are promoted to garment
92// "tones" and the mask then admits half the frame.
93// ★THE REAL TENSION, stated so the next attempt does not rediscover it: modes taken from the CORE ONLY
94// are safe but cannot discover a second tone (the second tone is precisely what the hue anchor
95// excluded); modes taken from the BOUNDING BOX discover it but drag in the background. The fix is
96// neither -- it is a DILATION of the core (pixels spatially adjacent to trusted garment), which admits
97// an adjacent second tone without admitting distant background. Not yet built.
98// Kept opt-in behind the `multi` verb so the champion path is untouched; no capability claim is made.
99const GM_HUE_BINS:   i64 = 36    // 10 degrees per bin: coarse enough to be robust to dithering noise
100const GM_MODE_MIN_PM: i64 = 60   // a bin must hold >=6% of the region to count as a tone, not noise
101const GM_MAX_MODES:  i64 = 6
102
103// ★F1143 -- DILATION, the fix for the bounding-box defect.
104// A bounding box is a SUPERSET containing everything the region deliberately excluded, which is why
105// histogramming it promoted background hues to garment "tones" (grade 371). A DILATION is the opposite:
106// it grows the trusted region by a bounded distance, so it can reach a tone that is ADJACENT to known
107// garment while never reaching background that is far away. One morphological step = one pixel of
108// reach, so the radius is an explicit, sweepable budget rather than an implicit rectangle.
109func gm_dilate(mask: *u8, w: i64, h: i64, iters: i64, out: *u8) -> i64 {
  let npix: i64 = w * h
  var i: i64 = 0
  while i < npix { out[i] = mask[i]; i = i + 1 }
  let tmp: *u8 = sys_mmap(npix)
  var it: i64 = 0
  while it < iters {
      i = 0
      while i < npix { tmp[i] = out[i]; i = i + 1 }
      var y: i64 = 0
      while y < h {
          var x: i64 = 0
          while x < w {
              if tmp[y*w + x] == (1 as u8) {
                  var dy: i64 = 0 - 1
                  while dy <= 1 {
                      var dx: i64 = 0 - 1
                      while dx <= 1 {
                          let nx2: i64 = x + dx
                          let ny2: i64 = y + dy
                          if nx2 >= 0 { if nx2 < w { if ny2 >= 0 { if ny2 < h {
                              out[ny2*w + nx2] = (1 as u8)
                          } } } }
                          dx = dx + 1
                      }
                      dy = dy + 1
                  }
              }
              x = x + 1
          }
          y = y + 1
      }
      it = it + 1
  }
  var n: i64 = 0
  i = 0
  while i < npix { if out[i] == (1 as u8) { n = n + 1 } i = i + 1 }
  return n
147}
148
149// Histogram hues over an explicit MASK (not a box). This is the corrected step 2.
150func gm_hue_modes_mask(rgb: *u8, npix: i64, region: *u8, sat_min: i64, out_modes: *i64) -> i64 {
  let hist: *i64 = sys_mmap(GM_HUE_BINS * 8) as *i64
  var b: i64 = 0
  while b < GM_HUE_BINS { hist[b] = 0; b = b + 1 }
  var total: i64 = 0
  var i: i64 = 0
  while i < npix {
      if region[i] == (1 as u8) {
          let r: i64 = rgb[i*3] as i64
          let g: i64 = rgb[i*3+1] as i64
          let b2: i64 = rgb[i*3+2] as i64
          if nx_color_kovac_skin_pixel(r, g, b2) == 0 {
              if ej_sat(r, g, b2) >= sat_min {
                  let hu: i64 = ej_hue(r, g, b2)
                  if hu >= 0 { hist[(hu * GM_HUE_BINS) / 360] = hist[(hu * GM_HUE_BINS) / 360] + 1; total = total + 1 }
              }
          }
      }
      i = i + 1
  }
  var nm: i64 = 0
  if total <= 0 { return 0 }
  b = 0
  while b < GM_HUE_BINS {
      if nm < GM_MAX_MODES {
          if (hist[b] * 1000) / total >= GM_MODE_MIN_PM {
              out_modes[nm] = (b * 360) / GM_HUE_BINS + (180 / GM_HUE_BINS)
              nm = nm + 1
          }
      }
      b = b + 1
  }
  return nm
183}
184
185// Corrected multi-modal pipeline: core -> DILATE by `reach` -> hue modes over the DILATED MASK ->
186// accept any mode INSIDE the dilated region -> largest connected component.
187func gm_segment_dilate(rgb: *u8, w: i64, h: i64, hue: i64, sat_min: i64, reach: i64, out_mask: *u8,
                     out_nmodes: *i64, out_kept_px: *i64, out_modes: *i64) -> i64 {
  let npix: i64 = w * h
  let core: *u8 = sys_mmap(npix)
  let nc: *i64 = sys_mmap(8)
  let kp: *i64 = sys_mmap(8)
  if gm_segment_noskin(rgb, w, h, hue, sat_min, core, nc, kp) == 0 { out_nmodes[0] = 0; out_kept_px[0] = 0; return 0 }
  let region: *u8 = sys_mmap(npix)
  gm_dilate(core, w, h, reach, region)
  let nm: i64 = gm_hue_modes_mask(rgb, npix, region, sat_min, out_modes)
  out_nmodes[0] = nm
  if nm == 0 { out_kept_px[0] = 0; return 0 }
  let bin2: *u8 = sys_mmap(npix)
  var i: i64 = 0
  while i < npix {
      bin2[i] = (255 as u8)
      if region[i] == (1 as u8) {
          let r: i64 = rgb[i*3] as i64
          let g: i64 = rgb[i*3+1] as i64
          let b3: i64 = rgb[i*3+2] as i64
          if nx_color_kovac_skin_pixel(r, g, b3) == 0 {
              if ej_sat(r, g, b3) >= sat_min {
                  if gm_near_any_mode(ej_hue(r, g, b3), out_modes, nm) == 1 { bin2[i] = (0 as u8) }
              }
          }
      }
      i = i + 1
  }
  let labels: *i64 = sys_mmap(npix * 8) as *i64
  let boxes: *i64 = sys_mmap(GM_MAXCOMPS * 4 * 8) as *i64
  let ncomp: i64 = seg_components(bin2, w, h, labels, boxes, GM_MAXCOMPS)
  let keep: i64 = gm_largest_id(labels, npix, ncomp)
  var kept: i64 = 0
  i = 0
  while i < npix {
      out_mask[i] = (0 as u8)
      if keep > 0 { if labels[i] == keep { out_mask[i] = (1 as u8); kept = kept + 1 } }
      i = i + 1
  }
  out_kept_px[0] = kept
  return keep
228}
229
230// Bounding box of the seed mask (the region we trust to be garment). Returns pixel count.
231func gm_mask_bbox(mask: *u8, w: i64, h: i64, out4: *i64) -> i64 {
  var minx: i64 = w
  var miny: i64 = h
  var maxx: i64 = 0 - 1
  var maxy: i64 = 0 - 1
  var n: i64 = 0
  var i: i64 = 0
  while i < w*h {
      if mask[i] == (1 as u8) {
          let x: i64 = i % w
          let y: i64 = i / w
          if x < minx { minx = x }
          if y < miny { miny = y }
          if x > maxx { maxx = x }
          if y > maxy { maxy = y }
          n = n + 1
      }
      i = i + 1
  }
  out4[0] = minx
  out4[1] = miny
  out4[2] = maxx
  out4[3] = maxy
  return n
255}
256
257// Histogram the hues of non-skin saturated pixels inside the box, and emit every bin that clears the
258// share threshold as a mode (bin centre, degrees). Returns the mode count.
259func gm_hue_modes(rgb: *u8, w: i64, h: i64, bx: *i64, sat_min: i64, out_modes: *i64) -> i64 {
  let hist: *i64 = sys_mmap(GM_HUE_BINS * 8) as *i64
  var b: i64 = 0
  while b < GM_HUE_BINS { hist[b] = 0; b = b + 1 }
  var total: i64 = 0
  var y: i64 = bx[1]
  while y <= bx[3] {
      var x: i64 = bx[0]
      while x <= bx[2] {
          let i: i64 = y*w + x
          let r: i64 = rgb[i*3] as i64
          let g: i64 = rgb[i*3+1] as i64
          let bb2: i64 = rgb[i*3+2] as i64
          if nx_color_kovac_skin_pixel(r, g, bb2) == 0 {
              if ej_sat(r, g, bb2) >= sat_min {
                  let hu: i64 = ej_hue(r, g, bb2)
                  if hu >= 0 {
                      let bin: i64 = (hu * GM_HUE_BINS) / 360
                      hist[bin] = hist[bin] + 1
                      total = total + 1
                  }
              }
          }
          x = x + 1
      }
      y = y + 1
  }
  var nm: i64 = 0
  if total <= 0 { return 0 }
  b = 0
  while b < GM_HUE_BINS {
      if nm < GM_MAX_MODES {
          if (hist[b] * 1000) / total >= GM_MODE_MIN_PM {
              out_modes[nm] = (b * 360) / GM_HUE_BINS + (180 / GM_HUE_BINS)
              nm = nm + 1
          }
      }
      b = b + 1
  }
  return nm
299}
300
301func gm_near_any_mode(hue: i64, modes: *i64, nm: i64) -> i64 {
  var i: i64 = 0
  while i < nm {
      if ej_hue_dist(hue, modes[i]) <= EJ_HUE_TOL { return 1 }
      i = i + 1
  }
  return 0
308}
309
310// Full multi-modal pipeline: skin-aware core -> its box -> hue modes in that box -> accept ANY mode
311// (still non-skin, still saturated, still inside the region) -> keep the largest connected component.
312func gm_segment_multimodal(rgb: *u8, w: i64, h: i64, hue: i64, sat_min: i64, out_mask: *u8,
                         out_nmodes: *i64, out_kept_px: *i64, out_modes: *i64) -> i64 {
  let npix: i64 = w * h
  let core: *u8 = sys_mmap(npix)
  let nc: *i64 = sys_mmap(8)
  let kp: *i64 = sys_mmap(8)
  if gm_segment_noskin(rgb, w, h, hue, sat_min, core, nc, kp) == 0 { out_nmodes[0] = 0; out_kept_px[0] = 0; return 0 }
  let bx: *i64 = sys_mmap(32) as *i64
  if gm_mask_bbox(core, w, h, bx) == 0 { out_nmodes[0] = 0; out_kept_px[0] = 0; return 0 }
  let nm: i64 = gm_hue_modes(rgb, w, h, bx, sat_min, out_modes)
  out_nmodes[0] = nm
  if nm == 0 { out_kept_px[0] = 0; return 0 }
  // rebuild the candidate set accepting ANY discovered tone, confined to the trusted region
  let bin2: *u8 = sys_mmap(npix)
  var i: i64 = 0
  while i < npix { bin2[i] = (255 as u8); i = i + 1 }
  var y: i64 = bx[1]
  while y <= bx[3] {
      var x: i64 = bx[0]
      while x <= bx[2] {
          let p: i64 = y*w + x
          let r: i64 = rgb[p*3] as i64
          let g: i64 = rgb[p*3+1] as i64
          let b3: i64 = rgb[p*3+2] as i64
          if nx_color_kovac_skin_pixel(r, g, b3) == 0 {
              if ej_sat(r, g, b3) >= sat_min {
                  if gm_near_any_mode(ej_hue(r, g, b3), out_modes, nm) == 1 { bin2[p] = (0 as u8) }
              }
          }
          x = x + 1
      }
      y = y + 1
  }
  let labels: *i64 = sys_mmap(npix * 8) as *i64
  let boxes: *i64 = sys_mmap(GM_MAXCOMPS * 4 * 8) as *i64
  let ncomp: i64 = seg_components(bin2, w, h, labels, boxes, GM_MAXCOMPS)
  let keep: i64 = gm_largest_id(labels, npix, ncomp)
  var kept: i64 = 0
  i = 0
  while i < npix {
      out_mask[i] = (0 as u8)
      if keep > 0 { if labels[i] == keep { out_mask[i] = (1 as u8); kept = kept + 1 } }
      i = i + 1
  }
  out_kept_px[0] = kept
  return keep
358}
359
360// Skin-aware segmentation: candidate set excludes skin, then keep the largest connected region so the
361// boundary still follows real fabric rather than a rectangle.
362func gm_segment_noskin(rgb: *u8, w: i64, h: i64, hue: i64, sat_min: i64, out_mask: *u8,
                     out_ncomp: *i64, out_kept_px: *i64) -> i64 {
  let npix: i64 = w * h
  let bin: *u8 = sys_mmap(npix)
  gm_candidate_mask_noskin(rgb, npix, hue, sat_min, bin)
  let labels: *i64 = sys_mmap(npix * 8) as *i64
  let boxes: *i64 = sys_mmap(GM_MAXCOMPS * 4 * 8) as *i64
  let ncomp: i64 = seg_components(bin, w, h, labels, boxes, GM_MAXCOMPS)
  out_ncomp[0] = ncomp
  let keep: i64 = gm_largest_id(labels, npix, ncomp)
  var kept: i64 = 0
  var i: i64 = 0
  while i < npix {
      out_mask[i] = (0 as u8)
      if keep > 0 { if labels[i] == keep { out_mask[i] = (1 as u8); kept = kept + 1 } }
      i = i + 1
  }
  out_kept_px[0] = kept
  return keep
381}
382
383// Which component id has the most pixels? (The garment is the largest contiguous colour region.)
384// Returns 0 if there are none.
385func gm_largest_id(labels: *i64, npix: i64, ncomp: i64) -> i64 {
  if ncomp <= 0 { return 0 }
  let counts: *i64 = sys_mmap((ncomp + 1) * 8) as *i64
  var i: i64 = 0
  while i <= ncomp { counts[i] = 0; i = i + 1 }
  i = 0
  while i < npix {
      let l: i64 = labels[i]
      if l > 0 { if l <= ncomp { counts[l] = counts[l] + 1 } }
      i = i + 1
  }
  var best: i64 = 0
  var bestn: i64 = 0
  var c: i64 = 1
  while c <= ncomp {
      if counts[c] > bestn { bestn = counts[c]; best = c }
      c = c + 1
  }
  return best
404}
405
406// ---- SEEDED REGION GROWING AGAINST A LEARNED MODEL -------------------------------------------
407// WHY THIS EXISTS. The threshold mask above works only for a SOLID, SATURATED garment: a high floor
408// that excludes skin also excludes the garment's own SHADOWED FOLDS (measured: sat 140 spared the face
409// but recoloured only 602 permil of the dress). A patterned or dark garment defeats it outright, because
410// no single hue+floor describes the object.
411//
412// THE FIX IS TO STOP GUESSING A THRESHOLD AND LEARN ONE FROM THE IMAGE. Take a CONFIDENT CORE (the
413// largest strongly-saturated region -- pixels we are sure are fabric), measure that core's ACTUAL colour
414// spread, then grow outward through 8-connected neighbours that fit the core's own model. Two
415// constraints hold it in: ADJACENCY (it can only reach pixels touching the region) and the LEARNED MODEL
416// (skin sits far outside the fabric's saturation distribution, so growth stops at the neck instead of
417// flooding the face). Tolerances are DERIVED from the core's measured spread, not typed in by hand.
418const GM_SEED_SAT:   i64 = 170   // saturation floor for the CONFIDENT CORE only (deliberately strict:
                               // this seeds the model, it does not define the final mask)
420const GM_SPREAD_MIN: i64 = 24    // floor on a derived tolerance so a perfectly-flat core can still grow
421const GM_SPREAD_MUL: i64 = 3     // half-widths are this multiple of the core's mean absolute deviation
422
423// Measure the core's colour model: mean hue / sat / val and the mean-absolute-deviation of each.
424func gm_model(rgb: *u8, npix: i64, mask: *u8, out6: *i64) -> i64 {
  var n: i64 = 0
  var sh: i64 = 0
  var ss: i64 = 0
  var sv: i64 = 0
  var i: i64 = 0
  while i < npix {
      if mask[i] == (1 as u8) {
          let r: i64 = rgb[i*3] as i64
          let g: i64 = rgb[i*3+1] as i64
          let b: i64 = rgb[i*3+2] as i64
          sh = sh + ej_hue(r, g, b)
          ss = ss + ej_sat(r, g, b)
          sv = sv + ej_max3(r, g, b)
          n = n + 1
      }
      i = i + 1
  }
  if n == 0 { return 0 }
  let mh: i64 = sh / n
  let ms: i64 = ss / n
  let mv: i64 = sv / n
  // mean absolute deviation per channel = the object's own measured spread
  var dh: i64 = 0
  var ds: i64 = 0
  var dv: i64 = 0
  i = 0
  while i < npix {
      if mask[i] == (1 as u8) {
          let r: i64 = rgb[i*3] as i64
          let g: i64 = rgb[i*3+1] as i64
          let b: i64 = rgb[i*3+2] as i64
          dh = dh + ej_hue_dist(ej_hue(r, g, b), mh)
          var t: i64 = ej_sat(r, g, b) - ms
          if t < 0 { t = 0 - t }
          ds = ds + t
          t = ej_max3(r, g, b) - mv
          if t < 0 { t = 0 - t }
          dv = dv + t
          n = n
      }
      i = i + 1
  }
  out6[0] = mh
  out6[1] = ms
  out6[2] = mv
  var th: i64 = (dh / n) * GM_SPREAD_MUL
  var ts: i64 = (ds / n) * GM_SPREAD_MUL
  var tv: i64 = (dv / n) * GM_SPREAD_MUL
  if th < GM_SPREAD_MIN { th = GM_SPREAD_MIN }
  if ts < GM_SPREAD_MIN { ts = GM_SPREAD_MIN }
  if tv < GM_SPREAD_MIN { tv = GM_SPREAD_MIN }
  out6[3] = th
  out6[4] = ts
  out6[5] = tv
  return n
480}
481
482// ⚠MEASURED: a SYMMETRIC tolerance grows NOTHING. The confident core is high-saturation by
483// construction, so it learns a narrow, high-saturation model that cannot reach its own shadowed folds
484// (core 176,360 px, grown 0). The bootstrap is self-limiting.
485// ★THE FIX IS PHYSICAL, NOT A TUNED NUMBER: shading scales illumination, which drives VALUE and
486// SATURATION DOWN while leaving HUE essentially unchanged. So the acceptance region is ASYMMETRIC --
487// tight on hue (identity of the colour), tight upward on sat/val (nothing should be BRIGHTER than the
488// lit core), and generous downward (that direction is shadow, which is still the same fabric).
489const GM_SHADOW_MUL: i64 = 4   // how much further the model may reach in the shadow direction only
490
491func gm_fits(rgb: *u8, i: i64, m: *i64) -> i64 {
  let r: i64 = rgb[i*3] as i64
  let g: i64 = rgb[i*3+1] as i64
  let b: i64 = rgb[i*3+2] as i64
  // hue: the colour's identity -- symmetric and tight
  if ej_hue_dist(ej_hue(r, g, b), m[0]) > m[3] { return 0 }
  // saturation: allow far DOWN (shadow), little UP
  let ds: i64 = ej_sat(r, g, b) - m[1]
  if ds > m[4] { return 0 }
  if (0 - ds) > m[4] * GM_SHADOW_MUL { return 0 }
  // value: same asymmetry
  let dv: i64 = ej_max3(r, g, b) - m[2]
  if dv > m[5] { return 0 }
  if (0 - dv) > m[5] * GM_SHADOW_MUL { return 0 }
  return 1
506}
507
508// Grow the seed mask through 8-connected neighbours that fit the model. Explicit stack, no recursion.
509func gm_grow(rgb: *u8, w: i64, h: i64, mask: *u8, m: *i64) -> i64 {
  let npix: i64 = w * h
  let stack: *i64 = sys_mmap((npix + 1) * 8) as *i64
  var sp: i64 = 0
  var i: i64 = 0
  while i < npix { if mask[i] == (1 as u8) { stack[sp] = i; sp = sp + 1 } i = i + 1 }
  var grown: i64 = 0
  while sp > 0 {
      sp = sp - 1
      let cur: i64 = stack[sp]
      let cx: i64 = cur % w
      let cy: i64 = cur / w
      var dy: i64 = 0 - 1
      while dy <= 1 {
          var dx: i64 = 0 - 1
          while dx <= 1 {
              let nxp: i64 = cx + dx
              let nyp: i64 = cy + dy
              if nxp >= 0 { if nxp < w { if nyp >= 0 { if nyp < h {
                  let np: i64 = nyp * w + nxp
                  if mask[np] == (0 as u8) {
                      if gm_fits(rgb, np, m) == 1 {
                          mask[np] = (1 as u8)
                          stack[sp] = np
                          sp = sp + 1
                          grown = grown + 1
                      }
                  }
              } } } }
              dx = dx + 1
          }
          dy = dy + 1
      }
  }
  return grown
544}
545
546// Full learned pipeline: confident core -> model -> grow. Writes core px and grown px.
547// Returns total mask pixels (0 = no confident core found).
548func gm_segment_grow(rgb: *u8, w: i64, h: i64, hue: i64, out_mask: *u8,
                   out_core: *i64, out_grown: *i64, out_model: *i64) -> i64 {
  let npix: i64 = w * h
  let nc: *i64 = sys_mmap(8)
  let kp: *i64 = sys_mmap(8)
  // strict core: the pixels we are SURE are fabric
  let keep: i64 = gm_segment_sat(rgb, w, h, hue, GM_SEED_SAT, out_mask, nc, kp)
  out_core[0] = kp[0]
  out_grown[0] = 0
  if keep == 0 { return 0 }
  if gm_model(rgb, npix, out_mask, out_model) == 0 { return 0 }
  out_grown[0] = gm_grow(rgb, w, h, out_mask, out_model)
  var total: i64 = 0
  var i: i64 = 0
  while i < npix { if out_mask[i] == (1 as u8) { total = total + 1 } i = i + 1 }
  return total
564}
565
566// Full pipeline: rgb -> garment mask (1 = in garment, 0 = not). Writes the component count and the
567// kept component's pixel count. Returns the kept component id (0 = nothing found, mask all zero).
568func gm_segment_sat(rgb: *u8, w: i64, h: i64, hue: i64, sat_min: i64, out_mask: *u8,
                  out_ncomp: *i64, out_kept_px: *i64) -> i64 {
  let npix: i64 = w * h
  let bin: *u8 = sys_mmap(npix)
  gm_candidate_mask(rgb, npix, hue, sat_min, bin)
  let labels: *i64 = sys_mmap(npix * 8) as *i64
  let boxes: *i64 = sys_mmap(GM_MAXCOMPS * 4 * 8) as *i64
  let ncomp: i64 = seg_components(bin, w, h, labels, boxes, GM_MAXCOMPS)
  out_ncomp[0] = ncomp
  let keep: i64 = gm_largest_id(labels, npix, ncomp)
  var kept: i64 = 0
  var i: i64 = 0
  while i < npix {
      out_mask[i] = (0 as u8)
      if keep > 0 { if labels[i] == keep { out_mask[i] = (1 as u8); kept = kept + 1 } }
      i = i + 1
  }
  out_kept_px[0] = kept
  return keep
587}
nx_garment_lib.nx source

`nx_garment_lib.nx` source
