`nx_recolor.nx` source

↩ module page · 275 lines · 13058 B
1// nx_recolor.nx -- DETERMINISTIC MASKED RECOLOUR: a real colour-edit channel, no GPU, no re-roll.
2//
3// WHY. The GPU img2img loop could not perform a colour edit at all -- denoise strength preserves or
4// destroys, it does not steer an attribute (MEASURED: the dress stayed yellow at every denoise, edit
5// compliance 2 permil). For the specific, common case "make the garment a different colour", a diffusion
6// re-roll is the wrong tool: it is slow, non-deterministic, and it moves identity/pose/lighting you did
7// NOT ask to touch. A masked hue rotation is the right tool -- it changes ONLY the hue of the pixels that
8// were the target colour, keeps their saturation and value, and leaves every other pixel byte-identical.
9// So it preserves identity/pose/lighting BY CONSTRUCTION and scores maximally on BOTH judges at once,
10// which the diffusion loop provably could not.
11//
12// This is the honest scope line: it recolours, it does not add structure (no sequins, no new folds).
13// For pure colour edits it is exact and free; for structural edits the inpaint/ControlNet channels remain.
14//
15// Integer HSV throughout (never-brick #26). Reuses the judge's hue/sat/decoder so one definition of
16// "this pixel is that colour" governs both the edit and the judgement of the edit.
17// license_tier: ORIGINAL
18import "nx_editjudge_lib.nx"
19import "nx_garment_lib.nx"
20import "nx_png_write.nx"
21
22func rw(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
23func rnum(v: i64) -> i64 {
  let b: *u8 = sys_mmap(28)
  var m: i64 = v
  if m < 0 { sys_write(1, "-" as *u8, 1); m = 0 - m }
  let t: *u8 = sys_mmap(28)
  var k: i64 = 0
  if m == 0 { t[0] = (48 as u8); k = 1 }
  while m > 0 { t[k] = ((48 + (m % 10)) as u8); m = m / 10; k = k + 1 }
  var i: i64 = 0
  while i < k { b[i] = t[k - 1 - i]; i = i + 1 }
  sys_write(1, b, k)
  return 0
35}
36func r_streq(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  while a[i] != (0 as u8) { if a[i] != b[i] { return 0 } i = i + 1 }
  if b[i] != (0 as u8) { return 0 }
  return 1
41}
42func r_atoi(s: *u8) -> i64 {
  var v: i64 = 0
  var i: i64 = 0
  while s[i] != (0 as u8) { let c: i64 = (s[i] as i64) & 255; if c >= 48 { if c <= 57 { v = v*10 + (c-48) } } i = i + 1 }
  return v
47}
48
49// Reconstruct RGB for a target hue while preserving this pixel's value (max) and chroma (delta = max-min).
50// Standard HSV sextant placement done in integers; writes r/g/b at out[o..o+2].
51func r_paint(out: *u8, o: i64, target_hue: i64, vmax: i64, delta: i64) -> i64 {
  let mn: i64 = vmax - delta
  var hue: i64 = target_hue
  if hue < 0 { hue = 0 }
  if hue >= 360 { hue = hue - 360 }
  let region: i64 = hue / 60
  let rem: i64 = hue - region * 60
  let up: i64 = mn + (delta * rem) / 60
  let down: i64 = mn + (delta * (60 - rem)) / 60
  var r: i64 = 0
  var g: i64 = 0
  var b: i64 = 0
  if region == 0 { r = vmax; g = up; b = mn }
  else { if region == 1 { r = down; g = vmax; b = mn }
  else { if region == 2 { r = mn; g = vmax; b = up }
  else { if region == 3 { r = mn; g = down; b = vmax }
  else { if region == 4 { r = up; g = mn; b = vmax }
  else { r = vmax; g = mn; b = down } } } } }
  out[o] = (r as u8)
  out[o+1] = (g as u8)
  out[o+2] = (b as u8)
  return 0
73}
74
75func main(argc: i64, argv: *i64) -> i64 {
  if argc < 6 {
      rw("usage: nx_recolor recolor <in.png> <out.png> <from_hue> <to_hue> [x0 y0 x1 y1 (permil)]\n" as *u8)
      return 2
  }
  let verb: *u8 = argv[1] as *u8
  var use_segment: i64 = 0
  var use_grow: i64 = 0
  var use_skin: i64 = 0
  var use_rotate: i64 = 0
  if r_streq(verb, "segment" as *u8) == 1 { use_segment = 1 }
  if r_streq(verb, "grow" as *u8) == 1 { use_grow = 1 }
  if r_streq(verb, "skin" as *u8) == 1 { use_skin = 1 }
  // ROTATE = the skin-aware mask, but each pixel's hue is SHIFTED BY A DELTA rather than SET to one
  // value. For a solid garment the two are equivalent; for a PATTERNED or multi-tone one they are not:
  // setting an absolute hue FLATTENS the pattern into a single colour, while rotating preserves every
  // hue RELATIONSHIP inside the garment. A single hue anchor stops describing a patterned object at
  // all, so the operation -- not just the mask -- has to change.
  if r_streq(verb, "rotate" as *u8) == 1 { use_rotate = 1; use_skin = 1 }
  // MULTI: the multi-modal mask (accepts every tone the garment actually contains) driving a hue
  // ROTATION -- the pairing that finally handles a patterned garment. Rotation alone was inert
  // because a single-hue mask never admitted a second tone for it to preserve.
  var use_multi: i64 = 0
  // ⚠use_skin MUST be set too: the multi branch lives inside the skin-aware block. Omitting it made
  // `multi` fall silently through to the plain box path, so an entire measurement campaign graded the
  // NAIVE path while attributing the result to multi-modal code that never executed.
  if r_streq(verb, "multi" as *u8) == 1 { use_multi = 1; use_rotate = 1; use_skin = 1 }
  if use_segment == 0 { if use_grow == 0 { if use_skin == 0 { if use_multi == 0 { if r_streq(verb, "recolor" as *u8) == 0 { rw("{\"error\":\"unknown verb (recolor|segment|grow|skin|rotate|multi)\"}\n" as *u8); return 2 } } } } }
103
  // optional spatial box in permil of w/h; default full-frame. The box is what keeps a garment
  // recolour off the model's face -- skin shares the warm hue, so a hue mask alone is insufficient.
  var x0: i64 = 0
  var y0: i64 = 0
  var x1: i64 = 1000
  var y1: i64 = 1000
  if argc >= 10 { x0 = r_atoi(argv[6] as *u8); y0 = r_atoi(argv[7] as *u8); x1 = r_atoi(argv[8] as *u8); y1 = r_atoi(argv[9] as *u8) }
111
  let w: *i64 = sys_mmap(8)
  let h: *i64 = sys_mmap(8)
  let rgb: *u8 = ej_load_rgb(argv[2] as *u8, w, h)
  if rgb == (0 as *u8) { rw("{\"error\":\"cannot decode input PNG\"}\n" as *u8); return 3 }
  let from: i64 = r_atoi(argv[4] as *u8)
  let to: i64 = r_atoi(argv[5] as *u8)
  let npix: i64 = w[0] * h[0]
119
  var changed: i64 = 0
  var ncomp: i64 = 0
  var kept: i64 = 0
123
  if use_skin == 1 {
      // SKIN-AWARE: exclude skin via Kovac's YCbCr chroma classifier, then keep the largest connected
      // region. Separates in a DIFFERENT colour space from the hue that could not separate them, so
      // the saturation floor can stay LOW and the garment's shadowed folds survive.
      let smask: *u8 = sys_mmap(npix)
      let nc2: *i64 = sys_mmap(8)
      let kp2: *i64 = sys_mmap(8)
      var satmin2: i64 = EJ_SAT_MIN
      if argc >= 7 { satmin2 = r_atoi(argv[6] as *u8) }
      if use_multi == 1 {
          let modes: *i64 = sys_mmap(64) as *i64
          let nmo: *i64 = sys_mmap(8)
          // argv[7] = dilation reach in pixels (0 = no dilation, i.e. modes from the core alone).
          // Explicit and sweepable: the bounding-box version had an implicit, unbounded reach.
          var reach: i64 = 8
          if argc >= 8 { reach = r_atoi(argv[7] as *u8) }
          gm_segment_dilate(rgb, w[0], h[0], from, satmin2, reach, smask, nmo, kp2, modes)
          ncomp = nmo[0]
          kept = kp2[0]
          rw("{\"tones_found\":" as *u8); rnum(nmo[0]); rw(",\"hues\":[" as *u8)
          var mi: i64 = 0
          while mi < nmo[0] { if mi > 0 { rw("," as *u8) } rnum(modes[mi]); mi = mi + 1 }
          rw("]}\n" as *u8)
      } else {
      gm_segment_noskin(rgb, w[0], h[0], from, satmin2, smask, nc2, kp2)
      ncomp = nc2[0]
      kept = kp2[0]
      }
      var si: i64 = 0
      while si < npix {
          if smask[si] == (1 as u8) {
              let rr: i64 = rgb[si*3] as i64
              let gg: i64 = rgb[si*3+1] as i64
              let bb: i64 = rgb[si*3+2] as i64
              let mx: i64 = ej_max3(rr, gg, bb)
              let mn: i64 = ej_min3(rr, gg, bb)
              var tgt: i64 = to
              if use_rotate == 1 {
                  // shift THIS pixel's own hue by the requested delta -- pattern relationships survive
                  var d: i64 = to - from
                  tgt = ej_hue(rr, gg, bb) + d
                  while tgt < 0 { tgt = tgt + 360 }
                  while tgt >= 360 { tgt = tgt - 360 }
              }
              r_paint(rgb, si*3, tgt, mx, mx - mn)
              changed = changed + 1
          }
          si = si + 1
      }
  }
  if use_grow == 1 {
      // LEARNED MODEL: a confident high-saturation core -> measure that core's OWN colour spread ->
      // grow through adjacent pixels that fit it. Recovers shadowed folds a fixed floor rejects,
      // while adjacency + the learned saturation distribution stop it at the skin boundary.
      let gmask: *u8 = sys_mmap(npix)
      let core: *i64 = sys_mmap(8)
      let grown: *i64 = sys_mmap(8)
      let model: *i64 = sys_mmap(48) as *i64
      let total: i64 = gm_segment_grow(rgb, w[0], h[0], from, gmask, core, grown, model)
      ncomp = core[0]
      kept = total
      var gi: i64 = 0
      while gi < npix {
          if gmask[gi] == (1 as u8) {
              let rr: i64 = rgb[gi*3] as i64
              let gg: i64 = rgb[gi*3+1] as i64
              let bb: i64 = rgb[gi*3+2] as i64
              let mx: i64 = ej_max3(rr, gg, bb)
              let mn: i64 = ej_min3(rr, gg, bb)
              r_paint(rgb, gi*3, to, mx, mx - mn)
              changed = changed + 1
          }
          gi = gi + 1
      }
      rw("{\"learned_model\":{\"hue\":" as *u8); rnum(model[0])
      rw(",\"sat\":" as *u8); rnum(model[1])
      rw(",\"val\":" as *u8); rnum(model[2])
      rw(",\"tol_hue\":" as *u8); rnum(model[3])
      rw(",\"tol_sat\":" as *u8); rnum(model[4])
      rw(",\"tol_val\":" as *u8); rnum(model[5])
      rw("},\"core_px\":" as *u8); rnum(core[0])
      rw(",\"grown_px\":" as *u8); rnum(grown[0])
      rw("}\n" as *u8)
  }
  if use_segment == 1 {
      // SPATIAL COHERENCE: keep only the largest connected colour region (the garment). The face
      // falls away as its own component, and the boundary follows real fabric edges -- no rectangle,
      // no seam, and no threshold tuned to this particular photo.
      let mask: *u8 = sys_mmap(npix)
      let nc: *i64 = sys_mmap(8)
      let kp: *i64 = sys_mmap(8)
      // segment verb reuses argv[6] as the saturation floor (default EJ_SAT_MIN)
      var satmin: i64 = EJ_SAT_MIN
      if argc >= 7 { satmin = r_atoi(argv[6] as *u8) }
      gm_segment_sat(rgb, w[0], h[0], from, satmin, mask, nc, kp)
      ncomp = nc[0]
      kept = kp[0]
      var i: i64 = 0
      while i < npix {
          if mask[i] == (1 as u8) {
              let rr: i64 = rgb[i*3] as i64
              let gg: i64 = rgb[i*3+1] as i64
              let bb: i64 = rgb[i*3+2] as i64
              let mx: i64 = ej_max3(rr, gg, bb)
              let mn: i64 = ej_min3(rr, gg, bb)
              r_paint(rgb, i*3, to, mx, mx - mn)
              changed = changed + 1
          }
          i = i + 1
      }
  }
  if use_grow == 0 { if use_segment == 0 { if use_skin == 0 {
      var i: i64 = 0
      while i < npix {
          if ej_in_box(i, w[0], h[0], x0, y0, x1, y1) == 1 {
              let rr: i64 = rgb[i*3] as i64
              let gg: i64 = rgb[i*3+1] as i64
              let bb: i64 = rgb[i*3+2] as i64
              let sat: i64 = ej_sat(rr, gg, bb)
              if sat >= EJ_SAT_MIN {
                  let hue: i64 = ej_hue(rr, gg, bb)
                  if ej_hue_dist(hue, from) <= EJ_HUE_TOL {
                      let mx: i64 = ej_max3(rr, gg, bb)
                      let mn: i64 = ej_min3(rr, gg, bb)
                      r_paint(rgb, i*3, to, mx, mx - mn)
                      changed = changed + 1
                  }
              }
          }
          i = i + 1
      }
  } } }
256
  if nx_png_write_rgb(argv[3] as *u8, rgb, w[0], h[0]) != 0 {
      rw("{\"error\":\"cannot write output PNG\"}\n" as *u8)
      return 4
  }
  rw("{\"action\":\"RECOLORED\",\"mode\":\"" as *u8)
  if use_multi == 1 { rw("multi" as *u8) } else { if use_rotate == 1 { rw("rotate" as *u8) } else { if use_skin == 1 { rw("skin" as *u8) } else { if use_grow == 1 { rw("grow" as *u8) } else { if use_segment == 1 { rw("segment" as *u8) } else { rw("box" as *u8) } } } } }
  rw("\",\"w\":" as *u8); rnum(w[0])
  rw(",\"h\":" as *u8); rnum(h[0])
  rw(",\"from_hue\":" as *u8); rnum(from)
  rw(",\"to_hue\":" as *u8); rnum(to)
  rw(",\"pixels_changed\":" as *u8); rnum(changed)
  if use_segment == 1 {
      rw(",\"components\":" as *u8); rnum(ncomp)
      rw(",\"largest_component_px\":" as *u8); rnum(kept)
  }
  rw(",\"footprint_permil\":" as *u8); rnum((changed * 1000) / npix)
  rw(",\"note\":\"only matched pixels rotated; value+saturation+every other pixel byte-preserved\"}\n" as *u8)
  return 0
275}
nx_recolor.nx source

`nx_recolor.nx` source
