简单验证码识别

字数统计: 2.8k字   |   阅读时长: 14分

最近工作中经常遇到验证码识别的问题，大部分的验证码都比较简单，代码的结构也比较类似，于是抽空总结下，便于以后参考。

简单的验证码拥有几个明显的特征：

  1. 容易去除背景色
  2. 小字符集，比如:字母和数字
  3. 字符间隔比较大，没有字符粘连
  4. 字符比较规范，没有旋转、拉伸

注:本文只针对简单验证码

先来张图看看效果~

一、灰度化

灰度化就是把多通道的彩色图像，转为单通道的灰度图像，其目的是为了识别的方便，当前，前提是不影响识别的准确性。这里，采用r * 0.299 + g * 0.587 + b * 0.114公式进行灰度化。
为了方便的在C#中处理图像数据，我们定义一个ImageData类，用于存储Image中各个像素的值（这里直接存储灰度化后的值）。代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
/// <summary>
///     灰度化后的图像数据
/// </summary>
public class ImageData
{
	#region 数据属性
	/// <summary>
	///     图像宽度
	/// </summary>
	public int Width { get; set; }

	/// <summary>
	///     图像高度
	/// </summary>
	public int Height { get; set; }

	/// <summary>
	///     图像数据
	/// </summary>
	public byte[] Data { get; private set; }
	#endregion

	#region 索引器
	public byte this[int x, int y]
	{
		get => Data[y * Width + x];
		set => Data[y * Width + x] = value;
	}
	public byte this[int i]
	{
		get => Data[i];
		set => Data[i] = value;
	}
	public byte this[long i]
	{
		get => Data[i];
		set => Data[i] = value;
	}
	#endregion

	#region 构造函数
	public ImageData(int width, int height)
	{
		Width = width;
		Height = height;
		Data = new byte[width * height];
	}
	#endregion

	#region 静态方法
	/// <summary>
	///     Image转ImageData
	/// </summary>         
	public static unsafe ImageData FromImage(Image image)
	{
		var bitmap = new Bitmap(image);
		var width = bitmap.Width;
		var height = bitmap.Height;

		// get total locked pixels count
		int pixelCount = width * height;

		// Create rectangle to lock
		var rect = new Rectangle(0, 0, width, height);

		// get source bitmap pixel format size
		var depth = Image.GetPixelFormatSize(bitmap.PixelFormat);

		// Check if bpp (Bits Per Pixel) is 8, 24, or 32
		if (depth != 8 && depth != 24 && depth != 32)
		{
			throw new ArgumentException("Only 8, 24 and 32 bpp images are supported.");
		}

		// Lock bitmap and return bitmap data
		var bitmapData = bitmap.LockBits(rect, ImageLockMode.ReadOnly, bitmap.PixelFormat);

		// create byte array to copy pixel values
		int step = depth / 8;
		var ptr = bitmapData.Scan0;
		var stride = bitmapData.Stride;

		var imageData = new ImageData(width, height);
		for (var y = 0; y < height; y++)
		{
			var row = (byte*)ptr + (y * stride);
			for (var x = 0; x < width; x++)
			{
				var j = x * step;
				if (step == 4) // For 32 bpp get Red, Green, Blue and Alpha
				{
					byte b = row[j];
					byte g = row[j + 1];
					byte r = row[j + 2];
					byte a = row[j + 3]; // a
					imageData[x, y] = (byte)(r * 0.299 + g * 0.587 + b * 0.114);
				}
				else if (step == 3) // For 24 bpp get Red, Green and Blue
				{
					byte b = row[j];
					byte g = row[j + 1];
					byte r = row[j + 2];
					imageData[x, y] = (byte)(r * 0.299 + g * 0.587 + b * 0.114);
				}
				else if (step == 1) // For 8 bpp get color value (Red, Green and Blue values are the same)
				{
					byte c = row[j];
					imageData[x, y] = c;
				}
			}
		}

		bitmap.UnlockBits(bitmapData);
		return imageData;
	}
	#endregion
}

二、二值化

通常，灰度化后图像要进行降噪、增强等处理，由于验证码比较简单，这里就直接跳过了这些步骤。
二值化就是根据阈值参数，判断当前像素点是否是有效像素点，其目的是为了过滤背景色，这里简单粗暴的选择128。
二值化代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/// <summary>
///     灰度阈值变换
/// </summary>        
public ImageData Threshold(float thres)
{
	var imageData = new ImageData(Width, Height);
	for (var i = 0; i < Data.Length; i++)
	{
		var v = Data[i];
		imageData.Data[i] = (byte)(v < thres ? 0 : 255);
	}

	return imageData;
}

三、文本分割

文本分割是为了找到目标图像中文本所在的区域，是文本识别的基础。
这里采用种子填充法进行连通域分析，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
public delegate bool ColorComparator(byte cr);

/// <summary>
///     连通域分析组件
/// </summary>
class ConnectedComponent
{
    #region 数据属性
    /// <summary>
    ///     当前点的8个邻域,用于分析过程
    /// </summary>
    private readonly Point[] Positions = new Point[8];

    /// <summary>
    ///     颜色匹配
    /// </summary>
    public ColorComparator ColorComparator { get; set; }

    /// <summary>
    ///     识别的范围
    /// </summary>
    public Rectangle Roi { get; set; }

    /// <summary>
    ///     要识别图像
    /// </summary>
    public ImageData ImageData { get; set; }
    #endregion

    #region 构造函数
    public ConnectedComponent(ImageData imageData)
    {
        ColorComparator = cr => cr == 0;
        ImageData = imageData;
        Roi = new Rectangle(0, 0, imageData.Width, imageData.Height);
    }
    #endregion

    #region 公开方法

    /// <summary>
    ///     计算连通域
    /// </summary>
    public List<ConnectedRegion> GetRegions()
    {
        var width = ImageData.Width;
        var height = ImageData.Height;
        var stk = new Stack<Point>();
        var regionList = new List<ConnectedRegion>();
        var validRect = new Rectangle(Roi.Left + 1, Roi.Top + 1, Roi.Width - 2, Roi.Height - 2);

        var visited = new bool[height, width];//记录已访问过的点
        for (int y = 0; y < height; ++y)
        {
            for (int x = 0; x < width; ++x)
            {
                visited[y, x] = false;
            }
        }

        for (int x = 0; x < width; ++x)
        {
            for (int y = 0; y < height; ++y)
            {
                var pos = new Point(x, y);
                var pointList = Dfs(stk, ImageData, ref pos, ref validRect, visited);
                if (pointList != null)
                {
                    regionList.Add(pointList);
                }
            }
        }
        return regionList;
    }

    /// <summary>
    ///     种子填充
    /// </summary>
    private ConnectedRegion Dfs(Stack<Point> stk, ImageData bm, ref Point pos, ref Rectangle validRect, bool[,] visited)
    {
        /*1.访问第一个点*/
        if (visited[pos.Y, pos.X])
        {
            return null;
        }
        visited[pos.Y, pos.X] = true;
        var pixel = bm[pos.X, pos.Y];
        if (!ColorComparator(pixel))
        {
            return null;
        }
        stk.Push(pos);

        /*2.递归的访问邻域中的点*/
        var region = new ConnectedRegion();
        while (stk.Count > 0)
        {
            pos = stk.Pop();
            region.Points.Add(pos);
            GetConnectivity8PosList(pos);//获取当前点的8个邻域
            foreach (var position in Positions)
            {
                if (position.X >= validRect.Left && position.X <= validRect.Right && position.Y >= validRect.Top && position.Y <= validRect.Bottom && !visited[position.Y, position.X])
                {
                    visited[position.Y, position.X] = true;
                    pixel = bm[position.X, position.Y];
                    if (ColorComparator(pixel))
                    {
                        /*3.将邻域中的黑点压入到堆栈中*/
                        stk.Push(position);
                    }
                }
            }
        }

        region.UpdateRegion();
        return region;
    }

    /// <summary>
    ///     获取当前点的邻域
    /// </summary>
    private void GetConnectivity8PosList(Point pos)
    {
        Positions[0].X = pos.X;
        Positions[0].Y = pos.Y - 1;
        Positions[1].X = pos.X;
        Positions[1].Y = pos.Y + 1;
        Positions[2].X = pos.X - 1;
        Positions[2].Y = pos.Y;
        Positions[3].X = pos.X + 1;
        Positions[3].Y = pos.Y;
        Positions[4].X = pos.X - 1;
        Positions[4].Y = pos.Y - 1;
        Positions[5].X = pos.X + 1;
        Positions[5].Y = pos.Y - 1;
        Positions[6].X = pos.X - 1;
        Positions[6].Y = pos.Y + 1;
        Positions[7].X = pos.X + 1;
        Positions[7].Y = pos.Y + 1;
    }
    #endregion
}

/// <summary>
///     连通区域
/// </summary>
public class ConnectedRegion
{
    /// <summary>
    ///     连通区域中的点
    /// </summary>
    public List<Point> Points { get; } = new List<Point>();

    /// <summary>
    ///     包含连通域的最小矩形
    /// </summary>
    public Rectangle Region { get; private set; } = new Rectangle();

    /// <summary>
    ///     更新Region
    /// </summary>
    public void UpdateRegion()
    {
        int left = int.MaxValue, right = 0, top = int.MaxValue, bottom = 0;
        foreach (var p in Points)
        {
            if (p.X < left) left = p.X;
            if (p.X > right) right = p.X;

            if (p.Y < top) top = p.Y;
            if (p.Y > bottom) bottom = p.Y;
        }

        Region = new Rectangle(left, top, right - left + 1, bottom - top + 1);
    }

    /// <summary>
    ///     转换成ImageData
    /// </summary>
    public ImageData ToImageData()
    {
        var imageData = new ImageData(Region.Width, Region.Height);
        for (var x = 0; x < imageData.Width; x++)
        {
            for (var y = 0; y < imageData.Height; y++)
            {
                imageData[x, y] = 255;
            }
        }

        foreach (var p in Points)
        {
            imageData[p.X - Region.Left, p.Y - Region.Top] = 0;
        }

        return imageData;
    }
}

二值化后的图像中可能存在间断点，一个字符可能被分割成多个连通域，因此，我们把距离比较近的连通域合并起来（本文验证码是4个字符）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/*连通域合并*/
if (regions.Count > 4)
{
	for (var i = 0; i < regions.Count - 1; i++)
	{
		var r1 = regions[i];
		var r2 = regions[i + 1];

		if (r1.Region.Width + r2.Region.Width < 10 && r2.Region.Left - r1.Region.Right < 2)
		{
			//合并r1和r2                                              
			r1.Points.AddRange(r2.Points);
			r1.UpdateRegion();

			regions.Remove(r2);
		}
	}
}

之后，我们需要把每个识别区域进行归一化，即调整为20*20的标准结构，并将图像居中。代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//调整图像的大小为 20*20
private List<ImageData> imageDataList = new List<ImageData>();
private void 图像居中()
{
	if (regionList == null || regionList.Count != 4) return;

	imageDataList.Clear();
	foreach (var r in regionList)
	{
		var imageData = new ImageData(20, 20);
		for (var i = 0; i < imageData.Data.Length; i++) imageData[i] = 255;

		var tmp = r.ToImageData();
		var sx = (imageData.Width - tmp.Width) / 2;
		var sy = (imageData.Height - tmp.Height) / 2;

		for (var x = 0; x < tmp.Width; x++)
		{
			for (var y = 0; y < tmp.Height; y++)
			{
				imageData[sx + x, sy + y] = tmp[x, y];
			}
		}

		imageDataList.Add(imageData);
	}
}

四、文本识别

这里，我们采用模板匹配法进行文本识别。为了提高识别准确度，我们采用k邻近法（k选择10）。

1.收集标准样本

模板特征有很多种，最简单的方法就是把灰度化->二值化->文本分割->居中后的图像作为特征，直接保存起来，之后也是根据这个特征进行匹配。
特征收录的代码，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public void 收录()
{
	var labels = textBox_结果.Text.Trim();
	if (labels.Length != 4 || imageDataList.Count != 4)
	{
		MessageBox.Show("结果错误,请检查!");
		return;
	}

	for (var i = 0; i < 4; i++)
	{
		var label = labels[i];
		var feature = imageDataList[i];

		SampleHelper.Include(label, feature);
	}

	textBox_结果.Text = null;
	加载原始图片();
}

2.文本识别

文本识别就是根据上一步得到的特征，在标准模板库中进行匹配，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
public string 识别()
{
	var sb = new StringBuilder();
	for (var i = 0; i < imageDataList.Count; i++)
	{
		var imageData = imageDataList[i];

		var c = SampleHelper.Recognize(imageData);
		sb.Append(c);
	}

	return sb.ToString();
}

模本匹配的代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
/// <summary>
///     样本工具类
/// </summary>
public static class SampleHelper
{
	/// <summary>
	///     样本列表
	/// </summary>
	internal static List<Sample> SampleList { get; } = new List<Sample>();

	/// <summary>
	///     收录标准样本
	/// </summary>
	public static void Include(char label, ImageData feature)
	{
		var ls = new List<string>();
		for (var l = 0; l < feature.Data.Length; l++) ls.Add((255 - feature[l]).ToString());

		var line = label + " " + string.Join(",", ls.ToArray()) + Environment.NewLine;
		File.AppendAllText("sample.txt", line);

		SampleList.Add(Sample.Parse(line));
	}

	/// <summary>
	///     识别(K临近法)
	/// </summary>
	public static char Recognize(ImageData feature)
	{
		/*1.模板匹配*/
		var ls = new List<RecognizeResult>();
		foreach (var sample in SampleList)
		{
			var error = sample.Compare(feature);
			if (ls.Count == 0) {
				ls.Add(new RecognizeResult { Label = sample.Label, Error = error });
			}
			else
			{
				for (var i = 0; i < ls.Count; i++)
				{
					var item = ls[i];
					if (error < item.Error)
					{
						ls.Insert(i, new RecognizeResult { Label = sample.Label, Error = error });
						break;
					}
				}
			}                
		}

		/*2.距离最近的10个元素进行投票*/
		var dic = new Dictionary<char, int>();
		for (var i = 0; i < Math.Min(10, ls.Count); i++)
		{
			var v = ls[i].Label;
			if (dic.ContainsKey(v)) dic[v]++;
			else dic[v] = 1;
		}

		/*3.返回投票最多的*/
		var max = 0;
		var label = '\0';
		foreach (var item in dic)
		{
			if (max < item.Value)
			{
				max = item.Value;
				label = item.Key;
			}
		}

		return label;
	}

	/// <summary>
	///     加载标准模板
	/// </summary>
	public static void LoadSample()
	{
		if (!File.Exists("sample.txt")) return;

		SampleList.Clear();
		var lines = File.ReadAllLines("sample.txt");
		foreach (var line in lines)
		{
			if (string.IsNullOrEmpty(line)) continue;

			SampleList.Add(Sample.Parse(line));
		}
	}

	#region 内部类
	internal class Sample
	{
		public char Label { get; set; }
		public ImageData Feature { get; set; }
		public Sample(char label, ImageData feature)
		{
			Label = label;
			Feature = feature;
		}

		public double Compare(ImageData input)
		{
			if (input.Width != Feature.Width || input.Height != Feature.Height)
				throw new Exception("数据格式不正确.");

			double sum = 0;
			for (var i = 0; i < Feature.Data.Length; i++)
			{
				sum += Math.Abs(input[i] - Feature[i]);
			}

			return sum;
		}

		public static Sample Parse(string line)
		{
			var label = line[0];
			var featureTxt = line.Substring(2);

			var feature = new ImageData(20, 20);
			var ss = featureTxt.Split(',');
			for (var i = 0; i < ss.Length; i++)
			{
				var v = int.Parse(ss[i]);
				feature[i] = (byte)(255 - v);
			}

			return new Sample(label, feature);
		}
	}

	internal class RecognizeResult : IComparable
	{
		public char Label { get; set; }
		public double Error { get; set; }

		public int CompareTo(object obj)
		{
			var v = obj as RecognizeResult;
			if (v == null) return -1;

			return (int)(Error - v.Error);
		}
	}
	#endregion
}

五、参考资料

本文源代码(包含数据): http://pan.baidu.com/s/1pLjvqgN 密码：muak

赏

非常感谢,我会继续努力的！

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

真正使人进步的,是不断总结。