character_database.h

vc++数字图像识别技术典型案例

/******************************************************************************
 * 光学字符识别程序
 * 文件名：character_database.h
 * 功能  ：字符数据库定义文件
 * modified by [e-mail]
******************************************************************************/

#ifndef CHARACTER_DATABASE_H
#define CHARACTER_DATABASE_H

#include <assert.h>

#include <string>

#include "abstract_character.h"

class recognized_char_group
{
	public: 
		enum {
			max_group = 3	// group中的最大字符数目
		     };
	private:
		int	x,
			y,
			width,
			height;

		bool	with_epsilon;
		int	count;
		int	char_code[max_group];

	public:
		recognized_char_group();
		void clear();
		void set_geometrics(int x_pos, int y_pos, int char_width, int char_height);
		void add_to_group(int c_code);
		void add_char_to_group(char c);
		void add_epsilon() { with_epsilon=true; }
		void add_joker() { count=0; }

		bool epsilon() const { return with_epsilon; }
		int size() const { return count; }
		int get_code(int pos) const;
		char get_char(int pos) const;
		int get_x() const { return x; }
		int get_y() const { return y; }
		int get_width() const { return width; }
		int get_height() const { return height; }
};

ostream& operator<< (ostream& o, const recognized_char_group &group);

class character_database {
	public: 
		enum {
			dictionary_lookup_chars = 31,
			total_chars = 70
		     };
	private:
		static const float database_fileformat_version;
		static const char *const meta_char_name[total_chars];
		static const char char_code[total_chars];
		list<abstract_character> database[total_chars];

		struct mini_priority_queue
		{
			enum { queue_len=recognized_char_group::max_group+1 };
			float penalty[queue_len];
			int   char_index[queue_len];
			
			mini_priority_queue();
			void insert(int code, float char_penalty);
			float get_cut_off() { return penalty[queue_len-1]; }
		};
	public:
		character_database();
		~character_database();

		static char char_code_to_char(int c);
		static const char *char_code_to_char_name(int c);

		static int char_name_to_char_code(char c);
		static int char_name_to_char_code(const string &str);

		void clear_char_def(int char_code);
		void clear_char_def(char c);

		void append_char_def(const abstract_character &ac, int char_code);
		void append_char_def(const abstract_character &ac, char c);

		void read(const char *file);
		void write(const char *file) const;

		int get_shape_variations(int char_code) const;
		abstract_character &get_shape(int char_code, int variation);

		recognized_char_group match(abstract_character &c);
		void clear();
};

// 内联函数

/******************************************************************************
 * 添加字符编码到组
 * 参数：c_code   要添加的元素
 * 返回：无
******************************************************************************/
inline void recognized_char_group::add_to_group(int c_code)
{
	if( count>=max_group )
		count=0;
	else
		char_code[count++]=c_code;
}

/******************************************************************************
 * 添加字符到组
 * 参数：c   要添加的字符
 * 返回：无
******************************************************************************/
inline void recognized_char_group::add_char_to_group(char c)
{
	add_to_group(character_database::char_name_to_char_code(c));
}

/******************************************************************************
 * 获得编码
 * 参数：pos   位置
 * 返回：无
******************************************************************************/
inline int recognized_char_group::get_code(int pos) const
{
	assert( pos>=0 && pos<count );
	return char_code[pos];
}

/******************************************************************************
 * 获得字符
 * 参数：c_code   要添加的元素
 * 返回：无
******************************************************************************/
inline char recognized_char_group::get_char(int pos) const
{
	return character_database::char_code_to_char(get_code(pos));
}

/******************************************************************************
 * 编码转换为字符
 * 参数：c    要转换的编码
 * 返回：字符
******************************************************************************/
inline char character_database::char_code_to_char(int c)
{
	assert( c>=0 && c<total_chars );
	return char_code[c];
}

/******************************************************************************
 * 编码转换为字符名称
 * 参数：c   要转换的编码
 * 返回：无
******************************************************************************/
inline const char *character_database::char_code_to_char_name(int c)
{
	assert( c>=0 && c<total_chars );
	return meta_char_name[c];
}

/******************************************************************************
 * 添加到组
 * 参数：c_code   要添加的元素
 * 返回：无
******************************************************************************/
inline int character_database::get_shape_variations(int char_code) const
{
	assert( char_code>=0 && char_code<total_chars );
	return database[char_code].size();
}

/******************************************************************************
 * 清空字符定义
 * 参数：char_code   字符编码
 * 返回：无
******************************************************************************/
inline void character_database::clear_char_def(char char_code)
{
	clear_char_def(char_name_to_char_code(char_code));
}

/******************************************************************************
 * 清空字符定义
 * 参数：char_code   字符编码
 * 返回：无
******************************************************************************/
inline void character_database::clear_char_def(int char_code)
{
	if( char_code<0 || char_code>total_chars )	// 尚未支持的字符
		return;
	database[char_code].clear();
}

/******************************************************************************
 * 追加字符定义
 * 参数：ac   抽象字符
 *       c    字符
 * 返回：无
******************************************************************************/
inline void character_database::append_char_def(const abstract_character &ac, char c)
{
	append_char_def(ac, char_name_to_char_code(c));
}

/******************************************************************************
 * 追加字符定义
 * 参数：ac        抽象字符
 *       char_code 字符编码
 * 返回：无
******************************************************************************/
inline void character_database::append_char_def(const abstract_character &ac, int char_code)
{
	if( char_code<0 || char_code>total_chars )	// char not yet supported
		return;
	database[char_code].push_back(ac);
}

#endif