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

1// nx_image_fidelity_test.nx -- prove the "rebuild exactly" measurement gate on three rebuilds of a
2// reference image: a PERFECT copy (must read LOSSLESS), a QUANTIZED rebuild (low bits dropped, must
3// read NEAR-LOSSLESS, high PSNR), and a BAD rebuild (heavy error, must read LOSSY, low PSNR). The
4// metric must rank them correctly -- the precision-measurement loop the generation stack needs.
5// license_tier: ORIGINAL
6
7import "nx_image_fidelity.nx"
8import "nx_syscalls.nx"
9
10func it_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
11func it_num(v: i64) -> i64 { let bb: *u8 = sys_mmap(28); var m: i64=v; if m<0 {m=0-m; sys_write(1,"-" as *u8,1)}; let t: *u8 = sys_mmap(28); var k: i64=0; if m==0 {t[0]=48;k=1}; while m>0 {t[k]=48+(m%10); m=m/10; k=k+1}; var i: i64=0; while i<k {bb[i]=t[k-1-i]; i=i+1}; sys_write(1, bb, k); return 0 }
12
13func main() -> i64 {
14    it_puts("=== rebuild EXACTLY: the fidelity measurement gate ===\n" as *u8)
15    let N: i64 = 256                                   // a 16x16 reference image
16    let ref: *i64 = sys_mmap(8 * (N + 8)) as *i64
17    let perf: *i64 = sys_mmap(8 * (N + 8)) as *i64
18    let quant: *i64 = sys_mmap(8 * (N + 8)) as *i64
19    let bad: *i64 = sys_mmap(8 * (N + 8)) as *i64
20    var i: i64 = 0
21    while i < N {
22        let p: i64 = (i * 7 + (i / 16) * 13) % 256      // a structured pattern (gradient + rows)
23        ref[i] = p
24        perf[i] = p                                     // perfect rebuild
25        quant[i] = p - (p % 4)                           // 2 low bits dropped (a near-lossless Q rebuild, ~42dB)
26        bad[i] = (p + 64) % 256                           // heavy error
27        i = i + 1
28    }
29    let mp: i64 = img_mse(ref, perf, N); let mq: i64 = img_mse(ref, quant, N); let mb: i64 = img_mse(ref, bad, N)
30    it_puts(" perfect : mse=" as *u8); it_num(mp); it_puts(" maxerr=" as *u8); it_num(img_max_abs_err(ref,perf,N)); it_puts(" psnr=" as *u8); it_num(img_psnr_db(mp)); it_puts("dB verdict=" as *u8); it_num(img_verdict(ref,perf,N)); it_puts(" (0=LOSSLESS)\n" as *u8)
31    it_puts(" quant   : mse=" as *u8); it_num(mq); it_puts(" maxerr=" as *u8); it_num(img_max_abs_err(ref,quant,N)); it_puts(" psnr=" as *u8); it_num(img_psnr_db(mq)); it_puts("dB verdict=" as *u8); it_num(img_verdict(ref,quant,N)); it_puts(" (1=NEAR)\n" as *u8)
32    it_puts(" bad     : mse=" as *u8); it_num(mb); it_puts(" maxerr=" as *u8); it_num(img_max_abs_err(ref,bad,N)); it_puts(" psnr=" as *u8); it_num(img_psnr_db(mb)); it_puts("dB verdict=" as *u8); it_num(img_verdict(ref,bad,N)); it_puts(" (2=LOSSY)\n" as *u8)
33
34    let r: *i64 = sys_mmap(8*8) as *i64
35    r[0] = 0; if img_verdict(ref,perf,N) == IMG_LOSSLESS { if mp == 0 { r[0] = 1 } }
36    r[1] = 0; if img_verdict(ref,quant,N) == IMG_NEAR { r[1] = 1 }
37    r[2] = 0; if img_verdict(ref,bad,N) == IMG_LOSSY { r[2] = 1 }
38    r[3] = 0; if img_psnr_db(mp) > img_psnr_db(mq) { if img_psnr_db(mq) > img_psnr_db(mb) { r[3] = 1 } } // ranks correctly
39    var pass: i64 = 0; var j: i64 = 0
40    while j < 4 { pass = pass + r[j]; j = j + 1 }
41    it_puts("----\n passed " as *u8); it_num(pass); it_puts("/4\n" as *u8)
42    if pass == 4 { it_puts(" GATE: 'exactly' is now MEASURABLE -- lossless vs near vs lossy ranked, PSNR ordered. The rebuild has a scorecard.\n" as *u8); sys_exit(0); return 0 }
43    it_puts(" FAIL\n" as *u8); sys_exit(1); return 1
44}
nx_image_fidelity_test.nx source

`nx_image_fidelity_test.nx` source
