`nx_imgxform.nx` source

↩ module page · 303 lines · 11274 B
1// nx_imgxform.nx -- DETERMINISTIC IMAGE-TRANSFORMATION BATTERY: the adversary set a reverse-image
2// engine must survive. TinEye's product claim is that it finds "modified versions" of an image --
3// resized, cropped, edited, colour-adjusted, watermarked. You cannot honestly say how close we are to
4// that without APPLYING those modifications and MEASURING what survives. This organ is that adversary:
5// 16 named transformation classes, pure integer, zero float, bit-reproducible (fixed LCG seed), each a
6// pure function grayscale(w,h) -> grayscale(w2,h2).
7//
8// It deliberately holds NO ranking or hashing logic -- it only DEFORMS. nx_imgbench does the measuring,
9// nx_phash/nx_visdesc do the describing. Single responsibility: this file's one job is "make a modified
10// copy of an image, the way the real world modifies images".
11//
12// The classes are chosen from what actually happens to an image on the open web (and therefore what
13// TinEye/Google/Yandex are judged on): CDN rescaling, thumbnail generation, re-encoding artifacts,
14// editorial cropping, letterboxing into a fixed aspect, mirroring, EXIF-rotation, brightness/contrast
15// "enhancement", additive sensor/compression noise, and watermark/caption bars.
16// license_tier: ORIGINAL
17import "syscalls.nx"
18
19const XF_IDENT:     i64 = 0
20const XF_SCALE50:   i64 = 1
21const XF_SCALE200:  i64 = 2
22const XF_BRIGHT_UP: i64 = 3
23const XF_BRIGHT_DN: i64 = 4
24const XF_CONTRAST:  i64 = 5
25const XF_CROP10:    i64 = 6
26const XF_CROP20:    i64 = 7
27const XF_CROP30:    i64 = 8
28const XF_PAD10:     i64 = 9
29const XF_FLIPH:     i64 = 10
30const XF_ROT90:     i64 = 11
31const XF_ROT180:    i64 = 12
32const XF_NOISE:     i64 = 13
33const XF_WATERMARK: i64 = 14
34const XF_BLOCKQ:    i64 = 15
35const XF_CROPSCALE: i64 = 16    // crop the centre THEN rescale it back to full size = occlusion + SCALE
36const XF_COUNT:     i64 = 17
37
38const XF_NOISE_AMP: i64 = 12     // +/- grey levels of additive noise (heavy-recompression scale)
39const XF_BRIGHT_D:  i64 = 40     // brightness offset applied by XF_BRIGHT_UP / XF_BRIGHT_DN
40const XF_WM_ROWPCT: i64 = 85     // watermark/caption bar starts at this percent of image height
41const XF_WM_LEVEL:  i64 = 235    // watermark bar grey level (near-white caption bar)
42const XF_QSTEP:     i64 = 16     // XF_BLOCKQ quantisation step (coarse-JPEG proxy)
43
44func xf_clamp(v: i64) -> i64 { if v < 0 { return 0 } if v > 255 { return 255 } return v }
45
46// MMIX LCG (Knuth) -- deterministic 64-bit stream so every transformation is bit-reproducible.
47func xf_rng(s: *i64) -> i64 { let x: i64 = s[0] * 0x5851F42D4C957F2D + 0x14057B7EF767814F; s[0] = x; return x }
48
49// human-readable class name (used by the ruler's report rows)
50func xf_name(kind: i64) -> *u8 {
  if kind == XF_IDENT     { return "identity      " as *u8 }
  if kind == XF_SCALE50   { return "rescale-50pct " as *u8 }
  if kind == XF_SCALE200  { return "rescale-200pct" as *u8 }
  if kind == XF_BRIGHT_UP { return "brightness+40 " as *u8 }
  if kind == XF_BRIGHT_DN { return "brightness-40 " as *u8 }
  if kind == XF_CONTRAST  { return "contrast+25pct" as *u8 }
  if kind == XF_CROP10    { return "crop-10pct    " as *u8 }
  if kind == XF_CROP20    { return "crop-20pct    " as *u8 }
  if kind == XF_CROP30    { return "crop-30pct    " as *u8 }
  if kind == XF_PAD10     { return "letterbox-10  " as *u8 }
  if kind == XF_FLIPH     { return "mirror-horiz  " as *u8 }
  if kind == XF_ROT90     { return "rotate-90     " as *u8 }
  if kind == XF_ROT180    { return "rotate-180    " as *u8 }
  if kind == XF_NOISE     { return "noise-pm12    " as *u8 }
  if kind == XF_WATERMARK { return "watermark-bar " as *u8 }
  if kind == XF_BLOCKQ    { return "recompress-8x8" as *u8 }
  if kind == XF_CROPSCALE { return "crop+rescale  " as *u8 }
  return "unknown       " as *u8
69}
70
71// nearest-neighbour resample (the CDN/thumbnailer operation) into a caller-sized buffer
72func xf_resample(gray: *u8, w: i64, h: i64, out: *u8, dw: i64, dh: i64) -> i64 {
  var oy: i64 = 0
  while oy < dh {
      let sy: i64 = (oy * h) / dh
      var ox: i64 = 0
      while ox < dw {
          let sx: i64 = (ox * w) / dw
          out[oy * dw + ox] = gray[sy * w + sx]
          ox = ox + 1
      }
      oy = oy + 1
  }
  return 0
85}
86
87// centre crop keeping keep_pct percent of EACH dimension (so crop-30 discards ~51 percent of the pixels)
88func xf_crop(gray: *u8, w: i64, h: i64, keep_pct: i64, outwh: *i64) -> *u8 {
  var nw: i64 = w * keep_pct / 100
  var nh: i64 = h * keep_pct / 100
  if nw < 1 { nw = 1 }
  if nh < 1 { nh = 1 }
  let x0: i64 = (w - nw) / 2
  let y0: i64 = (h - nh) / 2
  let out: *u8 = sys_mmap(nw * nh)
  var y: i64 = 0
  while y < nh {
      var x: i64 = 0
      while x < nw { out[y * nw + x] = gray[(y0 + y) * w + (x0 + x)]; x = x + 1 }
      y = y + 1
  }
  outwh[0] = nw
  outwh[1] = nh
  return out
105}
106
107// letterbox: surround the image with a black border of pct percent per side (fixed-aspect embedding)
108func xf_pad(gray: *u8, w: i64, h: i64, pct: i64, outwh: *i64) -> *u8 {
  let bx: i64 = w * pct / 100
  let by: i64 = h * pct / 100
  let nw: i64 = w + 2 * bx
  let nh: i64 = h + 2 * by
  let out: *u8 = sys_mmap(nw * nh)
  var i: i64 = 0
  let tot: i64 = nw * nh
  while i < tot { out[i] = 0 as u8; i = i + 1 }
  var y: i64 = 0
  while y < h {
      var x: i64 = 0
      while x < w { out[(by + y) * nw + (bx + x)] = gray[y * w + x]; x = x + 1 }
      y = y + 1
  }
  outwh[0] = nw
  outwh[1] = nh
  return out
126}
127
128// coarse block quantisation: pull each pixel halfway to its 8x8 block mean, then snap to XF_QSTEP.
129// A float-free stand-in for aggressive JPEG re-encoding (the dominant real-web degradation).
130func xf_blockq(gray: *u8, w: i64, h: i64, out: *u8) -> i64 {
  var by: i64 = 0
  while by < h {
      var bx: i64 = 0
      while bx < w {
          var sum: i64 = 0
          var cnt: i64 = 0
          var y: i64 = by
          while y < by + 8 {
              if y < h {
                  var x: i64 = bx
                  while x < bx + 8 {
                      if x < w { sum = sum + (gray[y * w + x] as i64); cnt = cnt + 1 }
                      x = x + 1
                  }
              }
              y = y + 1
          }
          var m: i64 = 0
          if cnt > 0 { m = sum / cnt }
          y = by
          while y < by + 8 {
              if y < h {
                  var x: i64 = bx
                  while x < bx + 8 {
                      if x < w {
                          let p: i64 = gray[y * w + x] as i64
                          var v: i64 = m + (p - m) / 2
                          v = (v / XF_QSTEP) * XF_QSTEP
                          out[y * w + x] = xf_clamp(v) as u8
                      }
                      x = x + 1
                  }
              }
              y = y + 1
          }
          bx = bx + 8
      }
      by = by + 8
  }
  return 0
171}
172
173// THE BATTERY. Returns a FRESH buffer holding the transformed image; outwh[0]=width, outwh[1]=height.
174// Never returns 0 for a valid kind, so callers do not need a null path for in-range classes.
175func xf_apply(kind: i64, gray: *u8, w: i64, h: i64, outwh: *i64) -> *u8 {
  let n: i64 = w * h
177
  if kind == XF_SCALE50 {
      var dw: i64 = w / 2
      var dh: i64 = h / 2
      if dw < 1 { dw = 1 }
      if dh < 1 { dh = 1 }
      let o: *u8 = sys_mmap(dw * dh)
      xf_resample(gray, w, h, o, dw, dh)
      outwh[0] = dw; outwh[1] = dh
      return o
  }
  if kind == XF_SCALE200 {
      let dw: i64 = w * 2
      let dh: i64 = h * 2
      let o: *u8 = sys_mmap(dw * dh)
      xf_resample(gray, w, h, o, dw, dh)
      outwh[0] = dw; outwh[1] = dh
      return o
  }
  if kind == XF_CROP10 { return xf_crop(gray, w, h, 90, outwh) }
  if kind == XF_CROP20 { return xf_crop(gray, w, h, 80, outwh) }
  if kind == XF_CROP30 { return xf_crop(gray, w, h, 70, outwh) }
  if kind == XF_PAD10  { return xf_pad(gray, w, h, 10, outwh) }
  if kind == XF_CROPSCALE {
      // the real-web cropped-thumbnail: keep the centre 70%, then RESAMPLE it back to the original
      // w x h. The surviving content is the same pixels shown at ~1.43x scale + a translated origin --
      // a similarity (scale+translation), which a translation-only matcher structurally cannot verify.
      let cwh: *i64 = sys_mmap(16) as *i64
      let c: *u8 = xf_crop(gray, w, h, 70, cwh)
      let o2: *u8 = sys_mmap(w * h)
      xf_resample(c, cwh[0], cwh[1], o2, w, h)
      outwh[0] = w; outwh[1] = h
      return o2
  }
211
  if kind == XF_ROT90 {
      let nw: i64 = h
      let nh: i64 = w
      let o: *u8 = sys_mmap(nw * nh)
      var y: i64 = 0
      while y < nh {
          var x: i64 = 0
          while x < nw { o[y * nw + x] = gray[(h - 1 - x) * w + y]; x = x + 1 }
          y = y + 1
      }
      outwh[0] = nw; outwh[1] = nh
      return o
  }
225
  // every remaining class is same-size
  let o: *u8 = sys_mmap(n)
  outwh[0] = w
  outwh[1] = h
230
  if kind == XF_IDENT {
      var i: i64 = 0
      while i < n { o[i] = gray[i]; i = i + 1 }
      return o
  }
  if kind == XF_BRIGHT_UP {
      var i: i64 = 0
      while i < n { o[i] = xf_clamp((gray[i] as i64) + XF_BRIGHT_D) as u8; i = i + 1 }
      return o
  }
  if kind == XF_BRIGHT_DN {
      var i: i64 = 0
      while i < n { o[i] = xf_clamp((gray[i] as i64) - XF_BRIGHT_D) as u8; i = i + 1 }
      return o
  }
  if kind == XF_CONTRAST {
      var i: i64 = 0
      while i < n { o[i] = xf_clamp(((gray[i] as i64) - 128) * 5 / 4 + 128) as u8; i = i + 1 }
      return o
  }
  if kind == XF_FLIPH {
      var y: i64 = 0
      while y < h {
          var x: i64 = 0
          while x < w { o[y * w + x] = gray[y * w + (w - 1 - x)]; x = x + 1 }
          y = y + 1
      }
      return o
  }
  if kind == XF_ROT180 {
      var y: i64 = 0
      while y < h {
          var x: i64 = 0
          while x < w { o[y * w + x] = gray[(h - 1 - y) * w + (w - 1 - x)]; x = x + 1 }
          y = y + 1
      }
      return o
  }
  if kind == XF_NOISE {
      let s: *i64 = sys_mmap(8) as *i64
      s[0] = 0x2545F4914F6CDD1D
      var i: i64 = 0
      while i < n {
          var r: i64 = xf_rng(s) >> 17
          if r < 0 { r = 0 - r }
          let d: i64 = (r % (2 * XF_NOISE_AMP + 1)) - XF_NOISE_AMP
          o[i] = xf_clamp((gray[i] as i64) + d) as u8
          i = i + 1
      }
      return o
  }
  if kind == XF_WATERMARK {
      var i: i64 = 0
      while i < n { o[i] = gray[i]; i = i + 1 }
      let y0: i64 = h * XF_WM_ROWPCT / 100
      var y: i64 = y0
      while y < h {
          var x: i64 = 0
          while x < w { o[y * w + x] = XF_WM_LEVEL as u8; x = x + 1 }
          y = y + 1
      }
      return o
  }
  if kind == XF_BLOCKQ {
      xf_blockq(gray, w, h, o)
      return o
  }
298
  // unknown class -> identity copy (fail-safe: never a null deref, never silent garbage)
  var i: i64 = 0
  while i < n { o[i] = gray[i]; i = i + 1 }
  return o
303}
nx_imgxform.nx source

`nx_imgxform.nx` source
