nx_haar_cascade_gate.nx source
↩ module page · 125 lines · 5828 B
1// nx_haar_cascade_gate.nx -- REFEREE for R-FACE-2 (nx_haar_cascade machinery).
2// 24x24 patterns:
3// FACE : rows 0-7 dark(40), rows 8-23 bright(180) -> strong full edge AND top edge
4// PARTIAL: rows 0-11 dark(40), rows 12-23 bright(180) -> strong full edge, weak top edge
5// NONFACE: flat 110 -> no edge
6// Hand-built 2-stage cascade (EDGE_V full @stage1, EDGE_V top-16 @stage2):
7// FACE -> passes both stages -> ACCEPT
8// PARTIAL -> passes stage1, fails stage2 -> REJECT (proves multi-stage AND)
9// NONFACE -> fails stage1 -> REJECT (early reject)
10// Validates weak vote, stage threshold, AND, and early-reject. The PARAMETERS
11// are hand-set (machinery test) -- real params come from training.
12// Every value PRINTED. stdout + knowledge/status/haar_cascade_gate.log. Exit 0/1.
13// Sovereign: syscalls + nx_image + nx_integral + nx_haar + nx_haar_cascade.
14// license_tier: ORIGINAL
15import "syscalls.nx"
16import "nx_image.nx"
17import "nx_integral.nx"
18import "nx_haar.nx"
19import "nx_haar_cascade.nx"
20
21const N: i64 = 24
22
23func gp(logfd: i64, s: *u8) -> i64 {
24 var n: i64 = 0
25 while s[n] != (0 as u8) { n = n + 1 }
26 sys_write(1, s, n)
27 if logfd > 0 { sys_write(logfd, s, n) }
28 return 0
29}
30func gn(logfd: i64, v: i64) -> i64 {
31 let bb: *u8 = sys_mmap(28)
32 var m: i64 = v
33 if m < 0 { sys_write(1, "-\x00" as *u8, 1); if logfd > 0 { sys_write(logfd, "-\x00" as *u8, 1) } m = 0 - m }
34 let t: *u8 = sys_mmap(28)
35 var k: i64 = 0
36 if m == 0 { t[0] = 48 as u8; k = 1 }
37 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
38 var i: i64 = 0
39 while i < k { bb[i] = t[k - 1 - i]; i = i + 1 }
40 sys_write(1, bb, k)
41 if logfd > 0 { sys_write(logfd, bb, k) }
42 return 0
43}
44
45// fill rows [r0,r1) with value v, rest with vrest, into a 1ch NxN image
46func make_band(v_top: i64, top_rows: i64, v_bot: i64) -> *Image {
47 let img: *Image = nx_image_alloc(N, N, 1)
48 var y: i64 = 0
49 while y < N {
50 var x: i64 = 0
51 while x < N {
52 var v: i64 = v_bot
53 if y < top_rows { v = v_top }
54 nx_image_set(img, x, y, 0, v)
55 x = x + 1
56 }
57 y = y + 1
58 }
59 return img
60}
61
62func main() -> i64 {
63 let logfd: i64 = sys_openat_append("knowledge/status/haar_cascade_gate.log\x00" as *u8, 0x1a4)
64 gp(logfd, "HAAR-CASCADE-GATE R-FACE-2 (cascade evaluator machinery)\n\x00" as *u8)
65
66 let face: *Image = make_band(40, 8, 180) // dark eye-band over bright
67 let partial: *Image = make_band(40, 12, 180) // edge at the middle
68 let nonface: *Image = nx_image_alloc(N, N, 1)
69 var y: i64 = 0
70 while y < N { var x: i64 = 0
71 while x < N { nx_image_set(nonface, x, y, 0, 110); x = x + 1 }
72 y = y + 1 }
73 let iiFa: *IntegralImage = nx_integral_build(face)
74 let iiPa: *IntegralImage = nx_integral_build(partial)
75 let iiNo: *IntegralImage = nx_integral_build(nonface)
76
77 // weaks (2 rows x 8): EDGE_V full, EDGE_V top-16
78 let weaks: *i64 = sys_mmap(2 * NX_WEAK_FIELDS * 8) as *i64
79 weaks[0] = NX_HAAR_EDGE_V; weaks[1] = 0; weaks[2] = 0; weaks[3] = 24; weaks[4] = 24; weaks[5] = 0 - 10000; weaks[6] = 1; weaks[7] = 100
80 weaks[8] = NX_HAAR_EDGE_V; weaks[9] = 0; weaks[10] = 0; weaks[11] = 24; weaks[12] = 16; weaks[13] = 0 - 20000; weaks[14] = 1; weaks[15] = 100
81 // stages (2 rows x 3): [weak_offset, count, stage_thresh]
82 let stages: *i64 = sys_mmap(2 * NX_STAGE_FIELDS * 8) as *i64
83 stages[0] = 0; stages[1] = 1; stages[2] = 50
84 stages[3] = 1; stages[4] = 1; stages[5] = 50
85
86 let w1: *i64 = (weaks as i64 + NX_WEAK_FIELDS * 8) as *i64 // 2nd weak row
87
88 let cf: i64 = nx_haar_cascade_eval(iiFa, stages, 2, weaks)
89 let cp: i64 = nx_haar_cascade_eval(iiPa, stages, 2, weaks)
90 let cn: i64 = nx_haar_cascade_eval(iiNo, stages, 2, weaks)
91 gp(logfd, " FACE edge_v_full=\x00" as *u8); gn(logfd, nx_haar_eval(iiFa, NX_HAAR_EDGE_V, 0, 0, 24, 24))
92 gp(logfd, " cascade=\x00" as *u8); gn(logfd, cf); gp(logfd, "\n\x00" as *u8)
93 gp(logfd, " PARTIAL edge_v_top16=\x00" as *u8); gn(logfd, nx_haar_eval(iiPa, NX_HAAR_EDGE_V, 0, 0, 24, 16))
94 gp(logfd, " cascade=\x00" as *u8); gn(logfd, cp); gp(logfd, "\n\x00" as *u8)
95 gp(logfd, " NONFACE edge_v_full=\x00" as *u8); gn(logfd, nx_haar_eval(iiNo, NX_HAAR_EDGE_V, 0, 0, 24, 24))
96 gp(logfd, " cascade=\x00" as *u8); gn(logfd, cn); gp(logfd, "\n\x00" as *u8)
97
98 // sub-component checks
99 let s0_no: i64 = nx_stage_eval(iiNo, weaks, 1, 50) // stage1 on nonface
100 let s0_pa: i64 = nx_stage_eval(iiPa, weaks, 1, 50) // stage1 on partial
101 let s1_fa: i64 = nx_stage_eval(iiFa, w1, 1, 50) // stage2 on face
102 let s1_pa: i64 = nx_stage_eval(iiPa, w1, 1, 50) // stage2 on partial
103 gp(logfd, " stage1(nonface)=\x00" as *u8); gn(logfd, s0_no); gp(logfd, " stage1(partial)=\x00" as *u8); gn(logfd, s0_pa)
104 gp(logfd, " stage2(face)=\x00" as *u8); gn(logfd, s1_fa); gp(logfd, " stage2(partial)=\x00" as *u8); gn(logfd, s1_pa); gp(logfd, "\n\x00" as *u8)
105
106 var ok: i64 = 1
107 if cf != 1 { ok = 0 } // FACE accepted
108 if cp != 0 { ok = 0 } // PARTIAL rejected (multi-stage AND)
109 if cn != 0 { ok = 0 } // NONFACE rejected (early)
110 if s0_no != 0 { ok = 0 } // stage1 rejects nonface
111 if s0_pa != 1 { ok = 0 } // stage1 accepts partial
112 if s1_fa != 1 { ok = 0 } // stage2 accepts face
113 if s1_pa != 0 { ok = 0 } // stage2 rejects partial
114
115 if ok == 1 {
116 gp(logfd, "HAAR-CASCADE-GATE result=ALL-PASS verdict=GREEN\n\x00" as *u8)
117 if logfd > 0 { sys_close(logfd) }
118 sys_exit(0)
119 return 0
120 }
121 gp(logfd, "HAAR-CASCADE-GATE result=FAIL verdict=RED\n\x00" as *u8)
122 if logfd > 0 { sys_close(logfd) }
123 sys_exit(1)
124 return 1
125}