nx_haar_gate.nx source
↩ module page · 111 lines · 4760 B
1// nx_haar_gate.nx -- REFEREE for R-FACE-1 (nx_haar).
2// 24x24 windows. Three synthetic patterns:
3// EDGE: left half luma=10, right half=200 (a vertical edge).
4// FLAT: all 50.
5// CHECK: 2x2 checker, TL/BR=200, TR/BL=10.
6// Asserts:
7// - EDGE_H on EDGE == hand-composed (left-rect - right-rect) AND == -54720.
8// - EDGE_V on EDGE == 0 (a vertical edge has no top/bottom contrast).
9// - every feature on FLAT == 0.
10// - FOUR on CHECK == hand-composed AND == 54720; FOUR on FLAT == 0 (discrim).
11// Every value PRINTED. stdout + knowledge/status/haar_gate.log. Exit 0/1.
12// Sovereign: syscalls + nx_image + nx_integral + nx_haar. license_tier: ORIGINAL
13import "syscalls.nx"
14import "nx_image.nx"
15import "nx_integral.nx"
16import "nx_haar.nx"
17
18const N: i64 = 24
19
20func gp(logfd: i64, s: *u8) -> i64 {
21 var n: i64 = 0
22 while s[n] != (0 as u8) { n = n + 1 }
23 sys_write(1, s, n)
24 if logfd > 0 { sys_write(logfd, s, n) }
25 return 0
26}
27func gn(logfd: i64, v: i64) -> i64 {
28 let bb: *u8 = sys_mmap(28)
29 var m: i64 = v
30 if m < 0 { sys_write(1, "-\x00" as *u8, 1); if logfd > 0 { sys_write(logfd, "-\x00" as *u8, 1) } m = 0 - m }
31 let t: *u8 = sys_mmap(28)
32 var k: i64 = 0
33 if m == 0 { t[0] = 48 as u8; k = 1 }
34 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
35 var i: i64 = 0
36 while i < k { bb[i] = t[k - 1 - i]; i = i + 1 }
37 sys_write(1, bb, k)
38 if logfd > 0 { sys_write(logfd, bb, k) }
39 return 0
40}
41
42func main() -> i64 {
43 let logfd: i64 = sys_openat_append("knowledge/status/haar_gate.log\x00" as *u8, 0x1a4)
44 gp(logfd, "HAAR-GATE R-FACE-1 window=24x24\n\x00" as *u8)
45
46 let imgE: *Image = nx_image_alloc(N, N, 1)
47 let imgF: *Image = nx_image_alloc(N, N, 1)
48 let imgC: *Image = nx_image_alloc(N, N, 1)
49 var y: i64 = 0
50 while y < N {
51 var x: i64 = 0
52 while x < N {
53 var ev: i64 = 10
54 if x >= 12 { ev = 200 }
55 nx_image_set(imgE, x, y, 0, ev)
56 nx_image_set(imgF, x, y, 0, 50)
57 var cv: i64 = 10
58 if x < 12 { if y < 12 { cv = 200 } }
59 if x >= 12 { if y >= 12 { cv = 200 } }
60 nx_image_set(imgC, x, y, 0, cv)
61 x = x + 1
62 }
63 y = y + 1
64 }
65 let iiE: *IntegralImage = nx_integral_build(imgE)
66 let iiF: *IntegralImage = nx_integral_build(imgF)
67 let iiC: *IntegralImage = nx_integral_build(imgC)
68
69 // EDGE_H on EDGE: feature vs hand-composed rect difference
70 let eh: i64 = nx_haar_eval(iiE, NX_HAAR_EDGE_H, 0, 0, N, N)
71 let eh_manual: i64 = nx_integral_rect_sum(iiE, 0, 0, 11, 23) - nx_integral_rect_sum(iiE, 12, 0, 23, 23)
72 let ev0: i64 = nx_haar_eval(iiE, NX_HAAR_EDGE_V, 0, 0, N, N)
73 gp(logfd, " EDGE: edge_h=\x00" as *u8); gn(logfd, eh); gp(logfd, " (manual=\x00" as *u8); gn(logfd, eh_manual)
74 gp(logfd, ") edge_v=\x00" as *u8); gn(logfd, ev0); gp(logfd, "\n\x00" as *u8)
75
76 // FLAT: all features zero
77 let fh: i64 = nx_haar_eval(iiF, NX_HAAR_EDGE_H, 0, 0, N, N)
78 let fv: i64 = nx_haar_eval(iiF, NX_HAAR_EDGE_V, 0, 0, N, N)
79 let fl: i64 = nx_haar_eval(iiF, NX_HAAR_LINE_H, 0, 0, N, N)
80 let f4: i64 = nx_haar_eval(iiF, NX_HAAR_FOUR, 0, 0, N, N)
81 gp(logfd, " FLAT: edge_h=\x00" as *u8); gn(logfd, fh); gp(logfd, " edge_v=\x00" as *u8); gn(logfd, fv)
82 gp(logfd, " line_h=\x00" as *u8); gn(logfd, fl); gp(logfd, " four=\x00" as *u8); gn(logfd, f4); gp(logfd, "\n\x00" as *u8)
83
84 // CHECK: four-feature vs hand-composed
85 let c4: i64 = nx_haar_eval(iiC, NX_HAAR_FOUR, 0, 0, N, N)
86 let c4_manual: i64 = (nx_integral_rect_sum(iiC, 0, 0, 11, 11) + nx_integral_rect_sum(iiC, 12, 12, 23, 23)) - (nx_integral_rect_sum(iiC, 12, 0, 23, 11) + nx_integral_rect_sum(iiC, 0, 12, 11, 23))
87 gp(logfd, " CHECK: four=\x00" as *u8); gn(logfd, c4); gp(logfd, " (manual=\x00" as *u8); gn(logfd, c4_manual); gp(logfd, ")\n\x00" as *u8)
88
89 var ok: i64 = 1
90 if eh != eh_manual { ok = 0 } // eval == hand-composed
91 if eh != 0 - 54720 { ok = 0 } // exact expected
92 if ev0 != 0 { ok = 0 } // vertical edge -> no horizontal contrast
93 if fh != 0 { ok = 0 }
94 if fv != 0 { ok = 0 }
95 if fl != 0 { ok = 0 }
96 if f4 != 0 { ok = 0 } // flat -> all zero
97 if c4 != c4_manual { ok = 0 }
98 if c4 != 54720 { ok = 0 } // checker -> strong diagonal
99 if c4 <= f4 { ok = 0 } // discrimination: checker >> flat
100
101 if ok == 1 {
102 gp(logfd, "HAAR-GATE result=ALL-PASS verdict=GREEN\n\x00" as *u8)
103 if logfd > 0 { sys_close(logfd) }
104 sys_exit(0)
105 return 0
106 }
107 gp(logfd, "HAAR-GATE result=FAIL verdict=RED\n\x00" as *u8)
108 if logfd > 0 { sys_close(logfd) }
109 sys_exit(1)
110 return 1
111}