求教：如何识别字串组成的数字

qhsxq

----------------------------------------
--888-----888-----888-----888-----888---
-8---8---8---8---8---8---8---8---8---8--
-----8-------8---8---8---8---8-------8--
----8------88----8---8---8---8------8---
---8---------8---8---8---8---8-----8----
--8----------8---8---8---8---8----8-----
-8---8---8---8---8---8---8---8---8---8--
-88888----888-----888-----888----88888--
----------------------------------------
如图数字是23002，但怎么让机器识别呢？

wendaokoujin

我没有测试下面的代码，给你参考，你可以多给几组图给ai，这样会更准确的识别出所有这种规律的图

1. /**
   
2. * 识别由 '8'（前景）和 '-'（背景）构成的 ASCII 数字横排。
   
3. * 核心：按空列把整幅图切成单个数字，然后用七段数码管的7个区域做密度判定。
   
4. */
   
5. 
   
6. function parseArt(art, fg='8') {
   
7.   const lines = art.replace(/\r/g,'').split('\n').filter(l=>l.trim().length>0);
   
8.   const h = lines.length;
   
9.   const w = Math.max(...lines.map(l=>l.length));
   
10.   // 右侧用背景补齐，保证等宽
    
11.   const grid = Array.from({length:h}, (_,r)=>
    
12.     Array.from({length:w}, (_,c)=> (lines[r][c]||'-') === fg)
    
13.   );
    
14.   return {grid, h, w};
    
15. }
    
16. 
    
17. // 把整幅图按“全空白列”切成若干数字列区间
    
18. function splitDigits(grid) {
    
19.   const h = grid.length, w = grid[0].length;
    
20.   const colHasInk = c => grid.some(row => row[c]);
    
21.   const segments = [];
    
22.   let inRun = false, start = 0;
    
23.   for (let c=0;c
24.     if (colHasInk(c)) {
    
25.       if (!inRun){ inRun = true; start = c; }
    
26.     } else {
    
27.       if (inRun){
    
28.         segments.push([start, c-1]);
    
29.         inRun = false;
    
30.       }
    
31.     }
    
32.   }
    
33.   if (inRun) segments.push([start, w-1]);
    
34.   // 去掉过窄的碎片（噪声）
    
35.   return segments.filter(([s,e]) => e - s + 1 >= 2);
    
36. }
    
37. 
    
38. // 从列区间裁切出单个数字的像素矩阵，并上下裁边（去掉全背景的行）
    
39. function cropDigit(grid, colStart, colEnd) {
    
40.   const h = grid.length;
    
41.   let rTop = 0, rBot = h-1;
    
42.   // 找最上方含墨的行
    
43.   while (rTop < h && grid[rTop].slice(colStart, colEnd+1).every(v=>!v)) rTop++;
    
44.   // 找最下方含墨的行
    
45.   while (rBot >= 0 && grid[rBot].slice(colStart, colEnd+1).every(v=>!v)) rBot--;
    
46.   if (rTop > rBot) return null;
    
47.   const sub = [];
    
48.   for (let r=rTop;r<=rBot;r++){
    
49.     sub.push(grid[r].slice(colStart, colEnd+1));
    
50.   }
    
51.   return sub;
    
52. }
    
53. 
    
54. // 计算某个区域的“点亮密度”（true 比例）
    
55. function density(board, r0, r1, c0, c1) {
    
56.   r0 = Math.max(0, Math.min(r0, board.length-1));
    
57.   r1 = Math.max(0, Math.min(r1, board.length-1));
    
58.   c0 = Math.max(0, Math.min(c0, board[0].length-1));
    
59.   c1 = Math.max(0, Math.min(c1, board[0].length-1));
    
60.   if (r1 < r0 || c1 < c0) return 0;
    
61.   let cnt=0, tot=0;
    
62.   for (let r=r0;r<=r1;r++){
    
63.     for (let c=c0;c<=c1;c++){
    
64.       tot++;
    
65.       if (board[r][c]) cnt++;
    
66.     }
    
67.   }
    
68.   return tot ? cnt/tot : 0;
    
69. }
    
70. 
    
71. /**
    
72. * 把一个数字块用“七段”来判定：a,b,c,d,e,f,g
    
73. *  a: 顶横  b: 右上  c: 右下  d: 底横  e: 左下  f: 左上  g: 中横
    
74. * 返回 bitmask（按 abcdefg -> 6..0 位）
    
75. */
    
76. function sevenSegMask(board) {
    
77.   const H = board.length, W = board[0].length;
    
78.   // 为了鲁棒，区域占整体的一定比例，适配粗细不同
    
79.   const th = Math.max(1, Math.floor(H * 0.18));     // 横段厚度
    
80.   const tv = Math.max(1, Math.floor(W * 0.18));     // 竖段厚度
    
81.   const pad = Math.max(1, Math.floor(Math.min(H,W) * 0.08)); // 边缘留白
    
82.   const midR = Math.floor(H/2);
    
83. 
    
84.   // 各段的采样窗口
    
85.   const a = density(board, pad, pad+th-1, pad, W-1-pad);
    
86.   const d = density(board, H-1-pad-th+1, H-1-pad, pad, W-1-pad);
    
87.   const g = density(board, midR - Math.floor(th/2), midR + Math.ceil(th/2)-1, pad, W-1-pad);
    
88. 
    
89.   const f = density(board, pad, midR - Math.ceil(th/2), pad, pad+tv-1);
    
90.   const b = density(board, pad, midR - Math.ceil(th/2), W-1-pad-tv+1, W-1-pad);
    
91. 
    
92.   const e = density(board, midR + Math.floor(th/2), H-1-pad, pad, pad+tv-1);
    
93.   const c = density(board, midR + Math.floor(th/2), H-1-pad, W-1-pad-tv+1, W-1-pad);
    
94. 
    
95.   // 阈值：段区域内有一定比例的 '8' 就认为该段点亮
    
96.   const T = 0.35; // 可按需要微调
    
97.   const bit = v => v >= T ? 1 : 0;
    
98. 
    
99.   const bits = [
    
100.     bit(a), // a
     
101.     bit(b), // b
     
102.     bit(c), // c
     
103.     bit(d), // d
     
104.     bit(e), // e
     
105.     bit(f), // f
     
106.     bit(g)  // g
     
107.   ];
     
108.   // 组装成掩码（abc def g -> 6..0）
     
109.   return (bits[0]<<6)|(bits[1]<<5)|(bits[2]<<4)|(bits[3]<<3)|(bits[4]<<2)|(bits[5]<<1)|(bits[6]<<0);
     
110. }
     
111. 
     
112. // 标准七段到数字的映射（常见数码管编码）
     
113. const sevenSegToDigit = new Map([
     
114.   // a b c d e f g
     
115.   [0b1110111, 0], // 0: a b c d e f (g=0) -> 0b1110111?（按位需核对下顺序）
     
116.   [0b0100100, 1], // 1: b c
     
117.   [0b1011101, 2], // 2: a b d e g
     
118.   [0b1101101, 3], // 3: a b c d g
     
119.   [0b0101110, 4], // 4: b c f g
     
120.   [0b1101011, 5], // 5: a c d f g
     
121.   [0b1111011, 6], // 6: a c d e f g
     
122.   [0b0100101, 7], // 7: a b c（有的实现不亮 g）
     
123.   [0b1111111, 8], // 8: all
     
124.   [0b1101111, 9], // 9: a b c d f g
     
125. ]);
     
126. 
     
127. // 由于上面的位序容易混淆，提供一个更稳妥的映射构造器：用[a,b,c,d,e,f,g]布尔数组生成mask
     
128. function maskFromSegs([a,b,c,d,e,f,g]) {
     
129.   return (a<<6)|(b<<5)|(c<<4)|(d<<3)|(e<<2)|(f<<1)|(g<<0);
     
130. }
     
131. // 用布尔数组重建映射，避免手写二进制出错
     
132. const LUT = new Map([
     
133.   [maskFromSegs([1,1,1,1,1,1,0]), 0],
     
134.   [maskFromSegs([0,1,1,0,0,0,0]), 1],
     
135.   [maskFromSegs([1,1,0,1,1,0,1]), 2],
     
136.   [maskFromSegs([1,1,1,1,0,0,1]), 3],
     
137.   [maskFromSegs([0,1,1,0,0,1,1]), 4],
     
138.   [maskFromSegs([1,0,1,1,0,1,1]), 5],
     
139.   [maskFromSegs([1,0,1,1,1,1,1]), 6],
     
140.   [maskFromSegs([1,1,1,0,0,0,0]), 7],
     
141.   [maskFromSegs([1,1,1,1,1,1,1]), 8],
     
142.   [maskFromSegs([1,1,1,1,0,1,1]), 9],
     
143. ]);
     
144. 
     
145. function recognizeAsciiDigits(art, fg='8') {
     
146.   const {grid} = parseArt(art, fg);
     
147.   const segments = splitDigits(grid);
     
148.   const digits = [];
     
149.   for (const [cs,ce] of segments) {
     
150.     const block = cropDigit(grid, cs, ce);
     
151.     if (!block) { digits.push('?'); continue; }
     
152.     const mask = sevenSegMask(block);
     
153.     const d = LUT.get(mask);
     
154.     digits.push(d !== undefined ? String(d) : '?');
     
155.   }
     
156.   return digits.join('');
     
157. }
     
158. 
     
159. // ------------------ DEMO ------------------
     
160. 
     
161. const art = `
     
162. ----------------------------------------
     
163. --888-----888-----888-----888-----888---
     
164. -8---8---8---8---8---8---8---8---8---8--
     
165. -----8-------8---8---8---8---8-------8--
     
166. ----8------88----8---8---8---8------8---
     
167. ---8---------8---8---8---8---8-----8----
     
168. --8----------8---8---8---8---8----8-----
     
169. -8---8---8---8---8---8---8---8---8---8--
     
170. -88888----888-----888-----888----88888--
     
171. ----------------------------------------
     
172. `;
     
173. 
     
174. console.log(recognizeAsciiDigits(art)); // 期望输出: 23002
     

复制代码

qhsxq

非常感谢！

jarlyyn

分块，标准化，对比。

分块是从指定位置把待识别的图案裁出来。

标准化是把背景替换为标准字符，前景替换为标准字符，让后转成一个字符串。

对比是在事先准备好的字符串字典里找到对应的值。

forex

这不就是简单的点阵字吗