直接源码，就是这么干脆。。。
namespace Frame.Image
{
/// <summary>
///
/// </summary>
public class AspriseOCRLanguages
{
// Common used languages
/// <summary>eng (English) </summary>
public const String LANGUAGE_ENG = "eng";
/// <summary>spa (Spanish) </summary>
public const String LANGUAGE_SPA = "spa";
/// <summary>por (Portuguese)</summary>
public const String LANGUAGE_POR = "por";
/// <summary>deu (German) </summary>
public const String LANGUAGE_DEU = "deu";
/// <summary>fra (French) </summary>
public const String LANGUAGE_FRA = "fra";
// around 30 languages are supported - use their ISO 639 3-letter as the id
}
/// <summary>
/// Represents an Asprise OCR engine.
/// <a href='http://asprise.com/ocr/docs/html/?src=csharp_src' target='_blank'>Read the developer's guide here.</a>
/// </summary>
public class AspriseOCR
{
private const string OCR_DLL_NAME_32 = "aocr.dll";
private const string OCR_DLL_NAME_64 = "aocr_x64.dll";
/// <summary> Highest speed, accuracy may suffer - default option </summary>
public const String SPEED_FASTEST = "fastest";
/// <summary> less speed, better accuracy </summary>
public const String SPEED_FAST = "fast";
/// <summary>lowest speed, best accuracy </summary>
public const String SPEED_SLOW = "slow";
/// <summary>Recognize text </summary>
public const String RECOGNIZE_TYPE_TEXT = "text";
/// <summary>Recognize barcode </summary>
public const String RECOGNIZE_TYPE_BARCODE = "barcode";
/// <summary>Recognize both text and barcode </summary>
public const String RECOGNIZE_TYPE_ALL = "all";
/// <summary>Output recognition result as plain text </summary>
public const String OUTPUT_FORMAT_PLAINTEXT = "text";
/// <summary>Output recognition result in XML format with additional information if coordination, confidence, runtime, etc. </summary>
public const String OUTPUT_FORMAT_XML = "xml";
/// <summary>Output recognition result as searchable PDF </summary>
public const String OUTPUT_FORMAT_PDF = "pdf";
/// <summary>Output to editable format RTF (can be edited in MS Word) </summary>
public const String OUTPUT_FORMAT_RTF = "rtf";
// ------------------------ dictionary properties ------------------------
/// <summary>set to 'true' to skip using the default built in dict. Default value: 'false' - can only be used for StartEngine</summary>
public const String START_PROP_DICT_SKIP_BUILT_IN_DEFAULT = "START_PROP_DICT_SKIP_BUILT_IN_DEFAULT";
/// <summary>set to 'true' to skip using all built-in dicts. Default value: 'false' - can only be used for StartEngine </summary>
public const String START_PROP_DICT_SKIP_BUILT_IN_ALL = "START_PROP_DICT_SKIP_BUILT_IN_ALL";
/// <summary>Path to your custom dictionary (words are separated using line breaks). Default value: null. - can only be used for StartEngine </summary>
public const String START_PROP_DICT_CUSTOM_DICT_FILE = "START_PROP_DICT_CUSTOM_DICT_FILE";
/// <summary>Path to your custom templates (templates are separated using line breaks). Default value: null. - can only be used for StartEngine </summary>
public const String START_PROP_DICT_CUSTOM_TEMPLATES_FILE = "START_PROP_DICT_CUSTOM_TEMPLATES_FILE";
/// <summary>Percentage measuring the importance of the dictionary (0: not at all; 100: extremely important; default: 10) </summary>
public const String PROP_DICT_DICT_IMPORTANCE = "PROP_DICT_DICT_IMPORTANCE";
// ------------------------ general options ------------------------
/// <summary>Page type </summary>
public const String PROP_PAGE_TYPE = "PROP_PAGE_TYPE";
/// <summary>Page type value: auto </summary>
public const String PROP_PAGE_TYPE_AUTO_DETECT = "auto";
/// <summary>Page type value: a single block of text </summary>
public const String PROP_PAGE_TYPE_SINGLE_BLOCK = "single_block";
/// <summary>Page type value: a single column of text </summary>
public const String PROP_PAGE_TYPE_SINGLE_COLUMN = "single_column";
/// <summary>Page type value: a single line of text </summary>
public const String PROP_PAGE_TYPE_SINGLE_LINE = "single_line";
/// <summary>Page type value: a single word </summary>
public const String PROP_PAGE_TYPE_SINGLE_WORD = "single_word";
/// <summary>Page type value: a single char </summary>
public const String PROP_PAGE_TYPE_SINGLE_CHARACTOR = "single_char";
/// <summary>Page type value: scattered text </summary>
public const String PROP_PAGE_TYPE_SCATTERED = "scattered";
/// <summary>Limit charset to a set of predefined chars </summary>
public const String PROP_LIMIT_TO_CHARSET = "PROP_LIMIT_TO_CHARSET";
/// <summary>Set to 'true' to set the output level as word instead of the default, line. </summary>
public const String PROP_OUTPUT_SEPARATE_WORDS = "PROP_OUTPUT_SEPARATE_WORDS";
/// <summary>The DPI to be used to render the PDF file; default is 300 if not specified </summary>
public const String PROP_INPUT_PDF_DPI = "PROP_INPUT_PDF_DPI";
// ------------------------ Image pre-processing ------------------------
/// <summary>Image pre-processing type </summary>
public const String PROP_IMG_PREPROCESS_TYPE = "PROP_IMG_PREPROCESS_TYPE";
/// <summary>Use system default </summary>
public const String PROP_IMG_PREPROCESS_TYPE_DEFAULT = "default";
/// <summary>Default + page orientation detection </summary>
public const String PROP_IMG_PREPROCESS_TYPE_DEFAULT_WITH_ORIENTATION_DETECTION = "default_with_orientation_detection";
/// <summary>Custom, need to set PROP_IMG_PREPROCESS_CUSTOM_CMDS </summary>
public const String PROP_IMG_PREPROCESS_TYPE_CUSTOM = "custom";
/// <summary>Custom mage pre-processing command </summary>
public const String PROP_IMG_PREPROCESS_CUSTOM_CMDS = "PROP_IMG_PREPROCESS_CUSTOM_CMDS";
// ------------------------ Table detection ------------------------
/// <summary>table will be detected by default; set this property to true to skip detection. </summary>
public const String PROP_TABLE_SKIP_DETECTION = "PROP_TABLE_SKIP_DETECTION";
/// <summary>default is 31 if not specified </summary>
public const String PROP_TABLE_MIN_SIDE_LENGTH = "PROP_TABLE_MIN_SIDE_LENGTH";
/// <summary>Save intermediate images generated for debug purpose - don't specify or empty string to skip saving </summary>
public const String PROP_SAVE_INTERMEDIATE_IMAGES_TO_DIR = "PROP_SAVE_INTERMEDIATE_IMAGES_TO_DIR";
// ------------------------ PDF output specific ------------------------
/// <summary>PDF output file - required for PDF output. Valid prop value: absolute path to the target output file. </summary>
public const String PROP_PDF_OUTPUT_FILE = "PROP_PDF_OUTPUT_FILE";
/// <summary>The DPI of the images or '0' to auto-detect. Optional. Valid prop value: 0(default: auto-detect), 300, 200, etc. </summary>
public const String PROP_PDF_OUTPUT_IMAGE_DPI = "PROP_PDF_OUTPUT_IMAGE_DPI";
/// <summary>Font to be used for PDF output. Optional. Valid values: "serif" (default), "sans". </summary>
public const String PROP_PDF_OUTPUT_FONT = "PROP_PDF_OUTPUT_FONT";
/// <summary>Make text visible - for debugging and analysis purpose. Optional. Valid prop values false(default), true. </summary>
public const String PROP_PDF_OUTPUT_TEXT_VISIBLE = "PROP_PDF_OUTPUT_TEXT_VISIBLE";
/// <summary>Convert images into black/white to reduce PDF output file size. Optional. Valid prop values: false(default), true. </summary>
public const String PROP_PDF_OUTPUT_IMAGE_FORCE_BW = "PROP_PDF_OUTPUT_IMAGE_FORCE_BW";
/// <summary>Set to 'text' or 'xml' to return information when the output format is PDF </summary>
public const String PROP_PDF_OUTPUT_RETURN_TEXT = "PROP_PDF_OUTPUT_RETURN_TEXT";
/// <summary>Return text </summary>
public const String PROP_PDF_OUTPUT_RETURN_TEXT_FORMAT_PLAINTEXT = "text";
/// <summary>Return xml </summary>
public const String PROP_PDF_OUTPUT_RETURN_TEXT_FORMAT_XML = "xml";
/// <summary>Set to true to output PDF/A instead of normal PDF. </summary>
public const String PROP_PDF_OUTPUT_PDFA = "PROP_PDF_OUTPUT_PDFA";
/// <summary>Optionally specifies path to the custom font to be embedded in PDF/A </summary>
public const String PROP_PDF_OUTPUT_PDFA_FONT_FILE = "PROP_PDF_OUTPUT_PDFA_FONT_FILE";
// ------------------------ RTF specific ------------------------
/// <summary>RTF output file - required for RTF output. Valid prop value: absolute path to the target output file. </summary>
public const String PROP_RTF_OUTPUT_FILE = "PROP_RTF_OUTPUT_FILE";
/// <summary>default is LETTER, may set to A4. </summary>
public const String PROP_RTF_PAPER_SIZE = "PROP_RTF_PAPER_SIZE";
/// <summary>Return text in 'text' or 'xml' format when the output format is set to RTF. </summary>
public const String PROP_RTF_OUTPUT_RETURN_TEXT = "PROP_RTF_OUTPUT_RETURN_TEXT";
/// <summary>Return text </summary>
public const String PROP_RTF_OUTPUT_RETURN_TEXT_FORMAT_PLAINTEXT = "text";
/// <summary>Return xml </summary>
public const String PROP_RTF_OUTPUT_RETURN_TEXT_FORMAT_XML = "xml";
/// <summary>Do not change unless you are told so. </summary>
public static String CONFIG_PROP_SEPARATOR = "|";
/// <summary>Do not change unless you are told so. </summary>
public static String CONFIG_PROP_KEY_VALUE_SEPARATOR = "=";
/// <summary>Recognize all pages. </summary>
public const int PAGES_ALL = -1;
/// <summary>
/// Unmanaged code access (32bit).
/// </summary>
private static class OcrDll32
{
/// <summary>
///
/// </summary>
/// <returns></returns>
[DllImport(OCR_DLL_NAME_32, CharSet = CharSet.Ansi)]
public static extern IntPtr com_asprise_ocr_version();
/// <summary>
///
/// </summary>
/// <param name="queryOnly"></param>
/// <returns></returns>
[DllImport(OCR_DLL_NAME_32, CharSet = CharSet.Ansi)]
public static extern int com_asprise_ocr_setup(int queryOnly);
/// <summary>
///
/// </summary>
/// <returns></returns>
[DllImport(OCR_DLL_NAME_32, CharSet = CharSet.Ansi)]
public static extern IntPtr com_asprise_ocr_list_supported_langs();
/// <summary>
///
/// </summary>
/// <param name="lang"></param>
/// <param name="speed"></param>
/// <param name="propSpec"></param>
/// <param name="propSeparator"></param>
/// <param name="propKeyValueSpeparator"></param>
/// <returns></returns>
[DllImport(OCR_DLL_NAME_32, CharSet = CharSet.Ansi)]
public static extern IntPtr com_asprise_ocr_start(string lang, string speed, string propSpec, string propSeparator, string propKeyValueSpeparator);
/// <summary>
///
/// </summary>
/// <param name="handle"></param>
[DllImport(OCR_DLL_NAME_32, CharSet = CharSet.Ansi)]
public static extern void com_asprise_ocr_stop(Int64 handle);
/// <summary>
///
/// </summary>
/// <param name="handle"></param>
/// <param name="imgFiles"></param>
/// <param name="pageIndex"></param>
/// <param name="startX"></param>
/// <param name="startY"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="recognizeType"></param>
/// <param name="outputFormat"></param>
/// <param name="propSpec"></param>
/// <param name="propSeparator"></param>
/// <param name="propKeyValueSpeparator"></param>
/// <returns></returns>
[DllImport(OCR_DLL_NAME_32, EntryPoint = "com_asprise_ocr_recognize")]
public static extern IntPtr com_asprise_ocr_recognize(Int64 handle, string imgFiles, int pageIndex, int startX, int startY, int width, int height, string recognizeType, string outputFormat, string propSpec, string propSeparator, string propKeyValueSpeparator);
/// <summary>
///
/// </summary>
/// <param name="licenseeName"></param>
/// <param name="licenseCode"></param>
[DllImport(OCR_DLL_NAME_32, CharSet = CharSet.Ansi)]
public static extern void com_asprise_ocr_input_license(string licenseeName, string licenseCode);
/// <summary>
///
/// </summary>
/// <param name="handle"></param>
/// <param name="isArray"></param>
[DllImport(OCR_DLL_NAME_32, CharSet = CharSet.Ansi)]
public static extern void com_asprise_ocr_util_delete(Int64 handle, bool isArray);
/// <summary>
///
/// </summary>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="depth"></param>
/// <param name="indexed"></param>
/// <returns></returns>
[DllImport(OCR_DLL_NAME_32, CharSet = CharSet.Ansi)]
public static extern IntPtr com_asprise_image_new(int width, int height, int depth, bool indexed);
/// <summary>
///
/// </summary>
/// <param name="imgPtr"></param>
/// <param name="r"></param>
/// <param name="g"></param>
/// <param name="b"></param>
/// <param name="a"></param>
/// <returns></returns>
[DllImport(OCR_DLL_NAME_32, CharSet = CharSet.Ansi)]
public static extern bool com_asprise_image_add_color_to_map(Int64 imgPtr, int r, int g, int b, int a);
/// <summary>
///
/// </summary>
/// <param name="imgPtr"></param>
/// <returns></returns>
[DllImport(OCR_DLL_NAME_32, CharSet = CharSet.Ansi)]
public static extern IntPtr com_asprise_image_get_data(Int64 imgPtr);
/// <summary>
///
/// </summary>
/// <param name="imgPtr"></param>
/// <param name="file"></param>
/// <returns></returns>
[DllImport(OCR_DLL_NAME_32, CharSet = CharSet.Ansi)]
public static extern bool com_asprise_image_save(Int64 imgPtr, string file);
/// <summary>
///
/// </summary>
/// <param name="imgPtr"></param>
/// <returns></returns>
[DllImport(OCR_DLL_NAME_32, CharSet = CharSet.Ansi)]
public static extern bool com_asprise_image_destory(Int64 imgPtr);
}
/// <summary>
/// Unmanaged code access (64bit).
/// </summary>
private static class OcrDll64
{
[DllImport(OCR_DLL_NAME_64, CharSet = CharSet.Ansi)]
public static extern IntPtr com_asprise_ocr_version();
[DllImport(OCR_DLL_NAME_64, CharSet = CharSet.Ansi)]
public static extern int com_asprise_ocr_setup(int queryOnly);
[DllImport(OCR_DLL_NAME_64, CharSet = CharSet.Ansi)]
public static extern IntPtr com_asprise_ocr_list_supported_langs();
[DllImport(OCR_DLL_NAME_64, CharSet = CharSet.Ansi)]
public static extern IntPtr com_asprise_ocr_start(string lang, string speed, string propSpec, string propSeparator, string propKeyValueSpeparator);
[DllImport(OCR_DLL_NAME_64, CharSet = CharSet.Ansi)]
public static extern void com_asprise_ocr_stop(Int64 handle);
[DllImport(OCR_DLL_NAME_64, CharSet = CharSet.Ansi)]
public static extern IntPtr com_asprise_ocr_recognize(Int64 handle, string imgFiles, int pageIndex, int startX, int startY, int width, int height, string recognizeType, string outputFormat, string propSpec, string propSeparator, string propKeyValueSpeparator);
[DllImport(OCR_DLL_NAME_64, CharSet = CharSet.Ansi)]
public static extern void com_asprise_ocr_input_license(string licenseeName, string licenseCode);
[DllImport(OCR_DLL_NAME_64, CharSet = CharSet.Ansi)]
public static extern void com_asprise_ocr_util_delete(Int64 handle, bool isArray);
[DllImport(OCR_DLL_NAME_64, CharSet = CharSet.Ansi)]
public static extern IntPtr com_asprise_image_new(int width, int height, int depth, bool indexed);
[DllImport(OCR_DLL_NAME_64, CharSet = CharSet.Ansi)]
public static extern bool com_asprise_image_add_color_to_map(Int64 imgPtr, int r, int g, int b, int a);
[DllImport(OCR_DLL_NAME_64, CharSet = CharSet.Ansi)]
public static extern IntPtr com_asprise_image_get_data(Int64 imgPtr);
[DllImport(OCR_DLL_NAME_64, CharSet = CharSet.Ansi)]
public static extern bool com_asprise_image_save(Int64 imgPtr, string file);
[DllImport(OCR_DLL_NAME_64, CharSet = CharSet.Ansi)]
public static extern bool com_asprise_image_destory(Int64 imgPtr);
}
private IntPtr _handle = new IntPtr(0);
/// <summary>
/// Whether the OCR engine is currently running.
/// </summary>
public bool IsEngineRunning
{
get { return _handle.ToInt64() > 0; }
}
/// <summary>
/// Starts the OCR engine; does nothing if the engine has already been started.
/// </summary>
/// <param name="lang">e.g., "eng"</param>
/// <param name="speed">e.g., "fastest"</param>
/// <param name="startProperties">property specifications, can be a single Dictionary object or inline specification in pairs. Valid property names are defined in this class, e.g., START_PROP_DICT_CUSTOM_DICT_FILE, etc.</param>
public void StartEngine(string lang, string speed = SPEED_FASTEST, params object[] startProperties)
{
Dictionary<string, string> dict = ReadProperties(startProperties);
if (IsEngineRunning)
{
return;
}
if (lang == null || speed == null || lang.Trim().Length == 0 || speed.Trim().Length == 0)
{
throw new Exception("Invalid arguments.");
}
_handle = Is64BitProcess ?
OcrDll64.com_asprise_ocr_start(lang, speed, DictToString(dict), CONFIG_PROP_SEPARATOR, CONFIG_PROP_KEY_VALUE_SEPARATOR) :
OcrDll32.com_asprise_ocr_start(lang, speed, DictToString(dict), CONFIG_PROP_SEPARATOR, CONFIG_PROP_KEY_VALUE_SEPARATOR);
if (_handle.ToInt64() == 0)
{
throw new Exception("Failed to start engine. Error code: " + _handle.ToInt64());
}
}
/// <summary>
/// Stops the OCR engine; does nothing if it has already been stopped.
/// </summary>
public void StopEngine()
{
if (!IsEngineRunning)
{
return;
}
if (Is64BitProcess)
{
OcrDll64.com_asprise_ocr_stop(_handle.ToInt64());
}
else
{
OcrDll32.com_asprise_ocr_stop(_handle.ToInt64());
}
}
private Thread threadDoingOCR;
/// <summary>
/// Performs OCR on the given input bitmaps.
/// </summary>
/// <param name="bitmaps">List of bitmaps to perform OCR on</param>
/// <param name="startX">-1 for whole page or the starting x coordinate of the specified region</param>
/// <param name="startY">-1 for whole page or the starting y coordinate of the specified region</param>
/// <param name="width">-1 for whole page or the width of the specified region</param>
/// <param name="height">-1 for whole page or the height of the specified region</param>
/// <param name="recognizeType">valid values: RECOGNIZE_TYPE_TEXT, RECOGNIZE_TYPE_BARCODE or RECOGNIZE_TYPE_ALL.</param>
/// <param name="outputFormat">valid values: OUTPUT_FORMAT_PLAINTEXT, OUTPUT_FORMAT_XML, OUTPUT_FORMAT_PDF or OUTPUT_FORMAT_RTF.</param>
/// <param name="additionalProperties">additional properties, can be a single Dictionary object or inline specification in pairs. Valid property names are defined in this class, e.g., PROP_INCLUDE_EMPTY_BLOCK, etc.</param>
/// <returns>text (plain text, xml) recognized for OUTPUT_FORMAT_PLAINTEXT, OUTPUT_FORMAT_XML</returns>
public string Recognize(IList<Bitmap> bitmaps, int startX, int startY, int width, int height, string recognizeType, string outputFormat, params object[] additionalProperties)
{
IList<Int64> imgHandles = new List<Int64>();
string imgNames = "";
try
{
foreach (Bitmap bitmap in bitmaps)
{
if (bitmap == null)
{
continue;
}
Int64 imgPtr = AspriseOCR.ImageFrom(bitmap);
if (imgPtr == 0)
{
continue;
}
imgHandles.Add(imgPtr);
if (imgNames.Length > 0)
{
imgNames += ',';
}
imgNames += "image://" + imgPtr;
}
if (imgHandles.Count == 0 || imgNames.Length == 0)
{
return null;
}
return Recognize(imgNames, -1, startX, startY, width, height, recognizeType, outputFormat, additionalProperties);
}
finally
{
foreach (Int64 handle in imgHandles)
{
ImageDestory(handle);
}
}
}
/// <summary>
/// Performs OCR on the given input files.
/// </summary>
/// <param name="files">comma ',' separated image file path (JPEG, BMP, PNG, TIFF)</param>
/// <param name="pageIndex">-1 for all pages or the specified page (first page is 1) for multi-page image format like TIFF</param>
/// <param name="startX">-1 for whole page or the starting x coordinate of the specified region</param>
/// <param name="startY">-1 for whole page or the starting y coordinate of the specified region</param>
/// <param name="width">-1 for whole page or the width of the specified region</param>
/// <param name="height">-1 for whole page or the height of the specified region</param>
/// <param name="recognizeType">valid values: RECOGNIZE_TYPE_TEXT, RECOGNIZE_TYPE_BARCODE or RECOGNIZE_TYPE_ALL.</param>
/// <param name="outputFormat">valid values: OUTPUT_FORMAT_PLAINTEXT, OUTPUT_FORMAT_XML, OUTPUT_FORMAT_PDF or OUTPUT_FORMAT_RTF.</param>
/// <param name="additionalProperties">additional properties, can be a single Dictionary object or inline specification in pairs. Valid property names are defined in this class, e.g., PROP_INCLUDE_EMPTY_BLOCK, etc.</param>
/// <returns>text (plain text, xml) recognized for OUTPUT_FORMAT_PLAINTEXT, OUTPUT_FORMAT_XML</returns>
public string Recognize(string files, int pageIndex, int startX, int startY, int width, int height, string recognizeType, string outputFormat, params object[] additionalProperties)
{
if (threadDoingOCR != null)
{
throw new Exception("Currently " + threadDoingOCR + " is using this OCR engine. Please create multiple OCR engine instances for multi-threading. ");
}
Dictionary<string, string> dict = ReadProperties(additionalProperties);
if (outputFormat.Equals(OUTPUT_FORMAT_PDF))
{
string pdfOutputFile = dict.ContainsKey(PROP_PDF_OUTPUT_FILE) ? dict[PROP_PDF_OUTPUT_FILE] : null;
if (pdfOutputFile == null)
{
throw new Exception("You must specify PDF output through property named: " + PROP_PDF_OUTPUT_FILE);
}
if (!dict.ContainsKey(PROP_OUTPUT_SEPARATE_WORDS))
{
dict[PROP_OUTPUT_SEPARATE_WORDS] = "true"; // default as separate
}
}
if (outputFormat.Equals(OUTPUT_FORMAT_RTF))
{
string rtfOutputFile = dict.ContainsKey(PROP_RTF_OUTPUT_FILE) ? dict[PROP_RTF_OUTPUT_FILE] : null;
if (rtfOutputFile == null)
{
throw new Exception("You must specify RTF output through property named: " + PROP_RTF_OUTPUT_FILE);
}
}
try
{
threadDoingOCR = Thread.CurrentThread;
IntPtr ptr = (Is64BitProcess ?
OcrDll64.com_asprise_ocr_recognize(_handle.ToInt64(), files, pageIndex, startX, startY, width, height, recognizeType, outputFormat, DictToString(dict), CONFIG_PROP_SEPARATOR, CONFIG_PROP_KEY_VALUE_SEPARATOR) :
OcrDll32.com_asprise_ocr_recognize(_handle.ToInt64(), files, pageIndex, startX, startY, width, height, recognizeType, outputFormat, DictToString(dict), CONFIG_PROP_SEPARATOR, CONFIG_PROP_KEY_VALUE_SEPARATOR)
);
string s = Marshal.PtrToStringAnsi(ptr);
string sInUnicode = null;
if (s != null && s.Length > 0 && ptr.ToInt64() > 0)
{
sInUnicode = Utf8ToUnicode(s);
// clean up
DeleteC(ptr, true);
}
return sInUnicode;
}
finally
{
threadDoingOCR = null;
}
}
/// <summary>
///
/// </summary>
/// <param name="propSpec"></param>
/// <returns></returns>
internal static Dictionary<string, string> ReadProperties(Object[] propSpec)
{
Dictionary<string, string> dict = new Dictionary<string, string>();
if (propSpec == null || propSpec.Length == 0 || (propSpec.Length == 1 && propSpec[0] == null))
{
// nothing to do.
}
else if (propSpec.Length == 1 && (propSpec[0] as String != null))
{
// parse properties
dict = StringToDict((String)propSpec[0]);
}
else if (propSpec != null && propSpec.Length > 0 &&
(propSpec[0] as Dictionary<string, string> != null))
{
foreach (KeyValuePair<string, string> pair in (Dictionary<string, string>)propSpec[0])
{
if (pair.Key != null)
{
dict[pair.Key.ToString()] = pair.Value == null ? null : pair.Value.ToString();
}
}
}
else if (propSpec != null && propSpec.Length > 0)
{
if (propSpec.Length % 2 == 1)
{
throw new Exception("You must specify additional properties in key/value pair. Current length: " + propSpec.Length);
}
for (var p = 0; p < propSpec.Length; p += 2)
{
string key = (string)propSpec[p];
object val = propSpec[p + 1];
if (key != null)
{
dict[key] = val == null ? "" : val.ToString();
}
}
}
// validation
foreach (KeyValuePair<string, string> pair in dict)
{
if (pair.Key.Contains(CONFIG_PROP_KEY_VALUE_SEPARATOR))
{
throw new Exception("Please change CONFIG_PROP_KEY_VALUE_SEPARATOR to a different value as "" +
pair.Key + "" contains "" + CONFIG_PROP_KEY_VALUE_SEPARATOR + """);
}
if (pair.Value.Contains(CONFIG_PROP_SEPARATOR))
{
throw new Exception("Please change CONFIG_PROP_SEPARATOR to a different value as "" +
pair.Value + "" contains "" + CONFIG_PROP_SEPARATOR + """);
}
}
return dict;
}
/// <summary>
///
/// </summary>
/// <param name="s"></param>
/// <returns></returns>
internal static Dictionary<string, string> StringToDict(String s)
{
Dictionary<string, string> dict = new Dictionary<string, string>();
if (s == null || s.Trim().Length == 0)
{
return dict;
}
string[] props = s.Split(new string[] { CONFIG_PROP_SEPARATOR }, StringSplitOptions.RemoveEmptyEntries);
foreach (string prop in props)
{
string[] parts = prop.Split(new string[] { CONFIG_PROP_KEY_VALUE_SEPARATOR }, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length >= 2)
{
dict[parts[0]] = parts[1];
}
}
return dict;
}
/// <summary>
/// The library version.
/// </summary>
/// <returns>The library version.</returns>
public static string GetLibraryVersion()
{
return Marshal.PtrToStringAnsi(Is64BitProcess ?
OcrDll64.com_asprise_ocr_version() :
OcrDll32.com_asprise_ocr_version());
}
/// <summary>
/// Performs one-time setup; does nothing if setup has already been done.
/// </summary>
public static void SetUp()
{
string dllPath = LoadDll();
if (dllPath == null)
{
throw new SystemException("OCR dll not found. Please download the latest evaluation kit from asprise.com");
}
if (Is64BitProcess)
{
OcrDll64.com_asprise_ocr_setup(0);
}
else
{
OcrDll32.com_asprise_ocr_setup(0);
}
}
/// <summary>
/// Call this after setup is done; returns list of langs separated by ','
/// </summary>
/// <returns>The list of langs separated by ','</returns>
public static string ListSupportedLangs()
{
return Marshal.PtrToStringAnsi(Is64BitProcess ? OcrDll64.com_asprise_ocr_list_supported_langs() : OcrDll32.com_asprise_ocr_list_supported_langs());
}
/// <summary>Input the license code </summary>
/// <param name="licenseeName">Licensee name</param>
/// <param name="licenseCode">License code</param>
public static void InputLicense(string licenseeName, string licenseCode)
{
if (Is64BitProcess)
{
OcrDll64.com_asprise_ocr_input_license(licenseeName, licenseCode);
}
else
{
OcrDll32.com_asprise_ocr_input_license(licenseeName, licenseCode);
}
}
/// <summary>Finds the OCR dll in system path or from bundle and return the path to the dll. </summary>
public static string LoadDll()
{
// 1. Search path.
string dllFilePath = AspriseOCR.GetOcrDllPath();
if (dllFilePath == null)
{
// 2. Then parent folders
string parentFolder = AspriseOCR.DetectOcrDllInParentFolders();
if (parentFolder != null)
{
AspriseOCR.AddToSystemPath(parentFolder);
// log("Folder containing ocr dll detected: " + parentFolder);
}
}
dllFilePath = GetOcrDllPath();
if (dllFilePath != null)
{
return dllFilePath;
}
// 3. from DLL bundle
string fromBundle = AspriseOCR.ExtractDllFromBundleTo(Directory.GetCurrentDirectory(), true);
if (fromBundle != null)
{
// log("Using OCR dll from bundle: " + fromBundle);
}
return GetOcrDllPath();
}
/// <summary>
/// Search PATH and return the location of the ocr dll.
/// </summary>
/// <returns></returns>
protected static string GetOcrDllPath()
{
return SearchFileInPath(GetOcrDllName());
}
/// <summary>
/// The simple name of the ocr dll file.
/// </summary>
/// <returns></returns>
public static string GetOcrDllName()
{
return Is64BitProcess ? OCR_DLL_NAME_64 : OCR_DLL_NAME_32;
}
/// <summary>
/// Search the ancester directories and return the directory that contains ocr dll or null if not found.
/// </summary>
/// <returns></returns>
private static string DetectOcrDllInParentFolders()
{
string folder = AppDomain.CurrentDomain.BaseDirectory;
while (true)
{
if (File.Exists(Path.Combine(folder, GetOcrDllName())))
{
return folder;
}
else
{
folder = Path.GetDirectoryName(folder);
if (folder == null)
{
break;
}
}
}
return null;
}
/// <summary>
///
/// </summary>
/// <param name="dir"></param>
/// <param name="overwrite"></param>
/// <returns></returns>
private static string ExtractDllFromBundleTo(string dir, bool overwrite)
{
string bundleName = Is64BitProcess ? "asprise-ocr-dll-bundle-64" : "asprise-ocr-dll-bundle-32";
Assembly bundleAssemly = null;
foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())
{
string name = asm.GetName().Name;
if (asm.GetName().Name == bundleName)
{
bundleAssemly = asm;
break;
}
}
if (bundleAssemly == null)
{
Console.Error.WriteLine("Assembly not loaded: " + bundleName);
return null;
}
string resourceClassName = bundleName.Replace('-', '_') + ".Properties.Resources";
Type typeResources = bundleAssemly.GetType(resourceClassName, false);
if (typeResources == null)
{
Console.Error.WriteLine("OCR dll bundle not referenced: " + bundleName);
return null;
}
MethodInfo[] methods = typeResources.GetMethods();
MethodInfo methodAocrRes = null;
string dllMd5 = null;
for (int i = 0; methods != null && i < methods.Length; i++)
{
MethodInfo m = methods[i];
if (m.Name.StartsWith("get_aocr"))
{
methodAocrRes = m;
dllMd5 = m.Name.Substring(m.Name.LastIndexOf('_') + 1);
break;
}
}
if (methodAocrRes == null)
{
Console.Error.WriteLine("OCR dll bundle not referenced, but unable to find resource in " + typeResources);
return null;
}
string path = dir +
((dir.EndsWith("/") || dir.EndsWith("\")) ? "" : "\") +
GetOcrDllName();
if (!overwrite && File.Exists(path))
{
return null;
}
File.WriteAllBytes(path, (byte[])methodAocrRes.Invoke(null, new object[0]));
return bundleName;
}
/// <summary>
/// Returns the absolute path of the first occurrence
/// </summary>
/// <param name="fileSimpleName"></param>
/// <returns></returns>
protected static string SearchFileInPath(string fileSimpleName)
{
string path = GetSystemPath();
string[] folders = path.Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries);
// insert current dir to folders
string[] extended = new string[folders.Length + 1];
extended[0] = AppDomain.CurrentDomain.BaseDirectory + "bin\";
Array.Copy(folders, 0, extended, 1, folders.Length);
folders = extended;
for (int i = 0; i < folders.Length; i++)
{
string folder = folders[i];
folder = folder.Replace('/', '\');
if (!folder.EndsWith("\"))
{
folder += "\";
}
string file = folder + fileSimpleName;
if (File.Exists(file))
{
return file;
}
}
return null;
}
/// <summary>
/// Running in 64bit mode?
/// </summary>
protected static bool Is64BitProcess
{
get { return IntPtr.Size == 8; }
}
/// <summary>
/// Performs native C/C++ delete
/// </summary>
/// <param name="ptr">pointer</param>
/// <param name="isArray">whether delete []</param>
protected static void DeleteC(IntPtr ptr, bool isArray)
{
if (Is64BitProcess)
{
OcrDll64.com_asprise_ocr_util_delete(ptr.ToInt64(), isArray);
}
else
{
OcrDll32.com_asprise_ocr_util_delete(ptr.ToInt64(), isArray);
}
}
/// <summary>
/// Returns the system path
/// </summary>
/// <returns>System path</returns>
protected static string GetSystemPath()
{
return Environment.GetEnvironmentVariable("PATH");
}
/// <summary>
/// Adds the given directory to the PATH variable.
/// </summary>
/// <param name="dir">The folder to be added to PATH</param>
public static void AddToSystemPath(string dir)
{
Environment.SetEnvironmentVariable("PATH", dir + ";" + Environment.GetEnvironmentVariable("PATH"));
}
/// <summary>
///
/// </summary>
/// <param name="dict"></param>
/// <returns></returns>
public static string DictToString(Dictionary<string, string> dict)
{
StringBuilder sb = new StringBuilder();
foreach (KeyValuePair<string, string> pair in dict)
{
if (sb.Length > 0)
{
sb.Append(CONFIG_PROP_SEPARATOR);
}
sb.Append(pair.Key);
sb.Append(CONFIG_PROP_KEY_VALUE_SEPARATOR);
sb.Append(pair.Value);
}
return sb.ToString();
}
/// <summary>
/// Returns the ToString() for non-null object or ""/"null" for null.
/// </summary>
/// <param name="obj">target object</param>
/// <param name="nullAsEmpty">true to return "" for null; false "null"</param>
/// <returns></returns>
protected static string ObjectToString(object obj, bool nullAsEmpty = true)
{
if (obj == null)
{
return nullAsEmpty ? "" : "null";
}
return obj.ToString();
}
/// <summary>
/// Returns the first non-null object or null if all arguments are null.
/// </summary>
/// <param name="o"></param>
/// <param name="others"></param>
/// <returns></returns>
protected static object FirstNonNull(object o, params object[] others)
{
if (o != null)
{
return o;
}
for (var i = 0; others != null && i < others.Length; i++)
{
if (others[i] != null)
{
return others[i];
}
}
return null;
}
/// <summary>
/// Converts utf8 encoded string to unicode
/// </summary>
/// <param name="utf8String"></param>
/// <returns></returns>
protected static string Utf8ToUnicode(string utf8String)
{
Encoding ansiEncoding = Encoding.GetEncoding(1252);
byte[] utf8Bytes = new byte[utf8String.Length];
for (int i = 0; i < utf8String.Length; ++i)
{
utf8Bytes[i] = ansiEncoding.GetBytes(utf8String.Substring(i, 1))[0];
}
return Encoding.UTF8.GetString(utf8Bytes, 0, utf8Bytes.Length);
}
/// <summary>save the aocr.xsl to the specified directory </summary>
public static bool SaveAocrXslTo(string dir, bool overwrite)
{
string path = dir +
((dir.EndsWith("/") || dir.EndsWith("\")) ? "" : "\") +
"aocr.xsl";
if (!overwrite && File.Exists(path))
{
return false;
}
return true;
}
private static Int64 ImageCreate(int width, int height, int depth, bool indexed)
{
return Is64BitProcess ? OcrDll64.com_asprise_image_new(width, height, depth, indexed).ToInt64() :
OcrDll32.com_asprise_image_new(width, height, depth, indexed).ToInt64();
}
private static bool ImageAddIndexedColor(Int64 imgPtr, int r, int g, int b, int a)
{
return Is64BitProcess ? OcrDll64.com_asprise_image_add_color_to_map(imgPtr, r, g, b, a) : OcrDll32.com_asprise_image_add_color_to_map(imgPtr, r, g, b, a);
}
private static Int64 ImageGetData(Int64 imgPtr)
{
return Is64BitProcess ? OcrDll64.com_asprise_image_get_data(imgPtr).ToInt64() : OcrDll32.com_asprise_image_get_data(imgPtr).ToInt64();
}
private static bool ImageSave(Int64 imgPtr, string file)
{
return Is64BitProcess ? OcrDll64.com_asprise_image_save(imgPtr, file) : OcrDll32.com_asprise_image_save(imgPtr, file);
}
private static bool ImageDestory(Int64 imgPtr)
{
return Is64BitProcess ? OcrDll64.com_asprise_image_destory(imgPtr) : OcrDll32.com_asprise_image_destory(imgPtr);
}
private unsafe static Int64 ImageFrom(Bitmap bitmap)
{
int depth = 0;
if (bitmap.PixelFormat == PixelFormat.Format1bppIndexed)
{
depth = 1;
}
else if (bitmap.PixelFormat == PixelFormat.Format8bppIndexed)
{
depth = 8;
}
else if (bitmap.PixelFormat == PixelFormat.Format32bppArgb || bitmap.PixelFormat == PixelFormat.Format24bppRgb)
{
depth = 32;
}
if (depth == 0)
{
throw new Exception("Unsupported bitmap pixel format: " + bitmap.PixelFormat);
}
int width = bitmap.Width; int height = bitmap.Height;
bool indexed = (bitmap.PixelFormat & PixelFormat.Indexed) == PixelFormat.Indexed;
Int64 imgPtr = ImageCreate(width, height, depth, indexed);
if (imgPtr == 0)
{
throw new Exception("Failed to get image object from bitmap");
}
if (indexed)
{
ColorPalette palette = bitmap.Palette;
for (int i = 0; i < palette.Entries.Length; i++)
//for (int i = palette.Entries.Length - 1; i >= 0; i--)
{
Color color = palette.Entries[i];
if (!ImageAddIndexedColor(imgPtr, color.R, color.G, color.B, color.A))
{
throw new Exception("Failed to add index color to image");
}
}
}
Int64 imgDataPtr = ImageGetData(imgPtr);
BitmapData bitmapData = null;
try
{
bitmapData = bitmap.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, bitmap.PixelFormat);
int imgRowWidthWords = (width * depth + 31) / 32;
if (bitmap.PixelFormat == PixelFormat.Format1bppIndexed)
{
for (int r = 0; r < height; r++)
{
byte* bitmapRow = (byte*)bitmapData.Scan0 + (r * bitmapData.Stride);
uint* imgRow = (uint*)(imgDataPtr) + (r * imgRowWidthWords);
for (int c = 0; c < (width + 7) / 8; c++) /////////////////
{
//*(imgRow + c) = *(bitmapRow + c);
if (Is64BitProcess)
{
*(byte*)((ulong)((byte*)imgRow + c) ^ 3) = (byte)(255 - (byte)(*(bitmapRow + c)));
}
else
{
*(byte*)((uint)((byte*)imgRow + c) ^ 3) = (byte)(255 - (byte)(*(bitmapRow + c)));
}
}
}
}
else if (bitmap.PixelFormat == PixelFormat.Format8bppIndexed)
{
for (int r = 0; r < height; r++)
{
byte* bitmapRow = (byte*)bitmapData.Scan0 + (r * bitmapData.Stride);
uint* imgRow = (uint*)(imgDataPtr) + (r * imgRowWidthWords);
for (int c = 0; c < width; c++)
{
if (Is64BitProcess)
{
*(byte*)((ulong)((byte*)imgRow + c) ^ 3) = (byte)(*(bitmapRow + c));
}
else
{
*(byte*)((uint)((byte*)imgRow + c) ^ 3) = (byte)(*(bitmapRow + c));
}
}
}
}
else if (bitmap.PixelFormat == PixelFormat.Format24bppRgb)
{
for (int r = 0; r < height; r++)
{
byte* bitmapRow = (byte*)bitmapData.Scan0 + (r * bitmapData.Stride);
uint* imgRow = (uint*)(imgDataPtr) + (r * imgRowWidthWords);
for (int c = 0; c < width; c++)
{
byte* colorPtr = bitmapRow + (c * 3);
byte blue = colorPtr[0], green = colorPtr[1], red = colorPtr[2];
*(imgRow + c) = (uint)((red << 24) | (green << 16) | (blue << 8) | 255); ;
}
}
}
else if (bitmap.PixelFormat == PixelFormat.Format32bppArgb)
{
for (int r = 0; r < height; r++)
{
byte* bitmapRow = (byte*)bitmapData.Scan0 + (r * bitmapData.Stride);
uint* imgRow = (uint*)(imgDataPtr) + (r * imgRowWidthWords);
for (int c = 0; c < width; c++)
{
byte* colorPtr = bitmapRow + (c * 4);
byte blue = colorPtr[0], green = colorPtr[1], red = colorPtr[2], alpha = colorPtr[3];
*(imgRow + c) = (uint)((red << 24) | (green << 16) | (blue << 8) | alpha);
}
}
}
return imgPtr;
}
catch (Exception)
{
ImageDestory(imgPtr);
throw;
}
finally
{
if (bitmapData != null)
{
bitmap.UnlockBits(bitmapData);
}
}
}
}
/// <summary>
///
/// </summary>
public static class Aocr_ImageHelper
{
/// <summary>
///
/// </summary>
/// <param name="imageFilepath"></param>
/// <param name="lang"></param>
/// <returns></returns>
public static string ReadImageText(string imageFilepath, string lang = AspriseOCRLanguages.LANGUAGE_ENG)
{
AspriseOCR.SetUp(); // one-time setup
AspriseOCR aspriseOCR = new AspriseOCR();
aspriseOCR.StartEngine(lang);
string imageText = aspriseOCR.Recognize(imageFilepath, -1, -1, -1, -1, -1, AspriseOCR.RECOGNIZE_TYPE_ALL, AspriseOCR.OUTPUT_FORMAT_PLAINTEXT);
aspriseOCR.StopEngine();
return imageText;
}
/// <summary>
///
/// </summary>
/// <param name="bitmaps"></param>
/// <param name="lang"></param>
/// <returns></returns>
public static string ReadBitmapText(List<Bitmap> bitmaps, string lang = AspriseOCRLanguages.LANGUAGE_ENG)
{
AspriseOCR.SetUp(); // one-time setup
AspriseOCR aspriseOCR = new AspriseOCR();
aspriseOCR.StartEngine(lang);
string imageText = aspriseOCR.Recognize(bitmaps, -1, -1, -1, -1, AspriseOCR.RECOGNIZE_TYPE_ALL, AspriseOCR.OUTPUT_FORMAT_PLAINTEXT);
aspriseOCR.StopEngine();
return imageText;
}
}
}