private static async Task <int> GetNewKDA(int previousKDA)
{
string fileName = "X:\\Programming\\C#\\LoLTaser\\Captured Pictures\\Capture.png";
await GetScreen(fileName); // Creates the specified file (image)
try {
//Do the thing
Language language = new Language("en");
var stream = File.OpenRead(fileName);
var decoder = await BitmapDecoder.CreateAsync(stream.AsRandomAccessStream());
var bitmap = await decoder.GetSoftwareBitmapAsync();
var engine = OcrEngine.TryCreateFromLanguage(language);
var ocrResult = await engine.RecognizeAsync(bitmap).AsTask();
string r = SplitStart('/', ocrResult.Text);
r = SplitEnd('/', r);
stream.Close();
File.Delete(fileName);
int result = Convert.ToInt32(r);
return(result);
}
catch (Exception err) {
Console.WriteLine(err.Message);
File.Delete(fileName);
}
return(previousKDA);
}
/// <summary>
/// OCRを実行
/// </summary>
/// <param name="sbitmap"></param>
/// <returns></returns>
private async Task <OcrResult> RunOcr(SoftwareBitmap sbitmap)
{
OcrEngine engine = OcrEngine.TryCreateFromLanguage(new Windows.Globalization.Language("ja-JP"));
var result = await engine.RecognizeAsync(sbitmap);
return(result);
}
public async Task <OcrResult> HttpPostImage(Picture screenshot = null)
{
OcrEngine ocrEngine = OcrEngine.TryCreateFromLanguage(PreferredLang);
if (screenshot == null)
{
await LoadSampleImageFromFile();
}
else
{
this.bitmap = await screenshot.AsSoftwareBitmap();
}
if (bitmap.PixelWidth > OcrEngine.MaxImageDimension || bitmap.PixelHeight > OcrEngine.MaxImageDimension)
{
Debug.LogError("<MediaOCR> Image Resolution not supported.");
}
else
{
var ocrResult = await ocrEngine.RecognizeAsync(bitmap);
ParseResponseData(ocrResult);
}
return(OcrResult);
}
public async Task <string> ImageReaderAsync(string fileName, string language, bool parseText)
{
try
{
//var check = OcrEngine.IsLanguageSupported(new Language("zh-Hans"));
var check = OcrEngine.AvailableRecognizerLanguages.Count;
var engine = OcrEngine.TryCreateFromLanguage(new Language(language));
var file = await StorageFile.GetFileFromPathAsync(fileName);
var stream = await file.OpenAsync(FileAccessMode.Read);
var decoder = await BitmapDecoder.CreateAsync(stream);
var softwareBitmap = await decoder.GetSoftwareBitmapAsync();
var ocrResult = await engine.RecognizeAsync(softwareBitmap);
if (parseText)
{
var result = ParseText(ocrResult);
log.Info("Image Processed Successfully");
return(result);
}
log.Info("Image Processed Successfully");
return(ocrResult.Text);
}
catch (Exception e)
{
log.Error(string.Format("Error while parsing image: {0}", e.Message));
return(null);
}
}
public async void Init(OcrEngine ocrEngine, StorageFile file, CoreInputDeviceTypes inputTypesForMarking = CoreInputDeviceTypes.Mouse, Image myDebugImage = null)
{
if (ocrEngine == null)
{
this.OCREngine = OcrEngine.TryCreateFromLanguage(new Language("en"));
}
else
{
this.OCREngine = ocrEngine;
}
if (inputTypesForMarking == CoreInputDeviceTypes.None)
{
InputTypesForMarking = CoreInputDeviceTypes.Mouse;
}
else
{
InputTypesForMarking = inputTypesForMarking;
}
MyImageSourcePath = file.Path;
DebugCropImage = myDebugImage;
BitmapImage bim = new BitmapImage(new Uri(MyImageSourcePath));
bim.SetSource(await file.OpenReadAsync());
MyImage.Source = bim;
MyInkCanvas.InkPresenter.InputDeviceTypes = InputTypesForMarking;
}
public static List <string> Recognize(string language, Byte[] image, int width, int height)
{
if (!_engines.ContainsKey(language))
{
_engines.Add(language, OcrEngine.TryCreateFromLanguage(new Language(language)));
}
OcrEngine engine = _engines[language];
IBuffer buf = CryptographicBuffer.CreateFromByteArray(image);
image = null;
SoftwareBitmap sbitmap = SoftwareBitmap.CreateCopyFromBuffer(buf, BitmapPixelFormat.Bgra8, width, height);
Task <OcrResult> task = engine.RecognizeAsync(sbitmap).AsTask();
task.Wait();
OcrResult result = task.Result;
buf = null;
GC.Collect();
List <string> lines = new List <string>();
foreach (OcrLine line in result.Lines)
{
lines.Add(line.Text);
}
return(ProcessLines(lines, engine.RecognizerLanguage.LayoutDirection == LanguageLayoutDirection.Rtl));
}
private async Task RunOcrAndTranslate()
{
SoftwareBitmap softwareBitmap = captureImage.Tag as SoftwareBitmap;
OcrEngine ocrEngine = OcrEngine.TryCreateFromLanguage(sourceLanguageComboBox.SelectedItem as Windows.Globalization.Language);
var ocrResult = await ocrEngine.RecognizeAsync(softwareBitmap);
String resultString = ocrResult.Text;
if (ocrEngine.RecognizerLanguage.LanguageTag == "ja")
{
resultString = resultString.Replace(" ", "");
}
var sourceLanguage = sourceLanguageComboBox.SelectedItem as Windows.Globalization.Language;
String sourceLanguageTag = sourceLanguage.LanguageTag;
if (sourceLanguageTag.StartsWith("en"))
{
sourceLanguageTag = "en";
}
String destinationLanguageTag = GoogleLanguageTags[destinationLanguageComboBox.SelectedItem as String];
String textURL = HttpUtility.UrlEncode(resultString);
String navigateURL = $"https://translate.google.com/m/translate#{sourceLanguageTag}/{destinationLanguageTag}/{textURL}";
WebBrowserExtensions.LoadHtml(browser, "");
browser.Address = navigateURL;
}
private static async Task <string> RunOcr(MemoryStream memoryStream)
{
if (memoryStream == null || memoryStream.Length == 0)
{
return("");
}
using (var memoryRandomAccessStream = new InMemoryRandomAccessStream())
{
await memoryRandomAccessStream.WriteAsync(memoryStream.ToArray().AsBuffer());
OcrEngine engine = null;
if (!string.IsNullOrWhiteSpace(ConfigurationManager.AppSettings["LanguageCode"]))
{
engine = OcrEngine.TryCreateFromLanguage(new Language(ConfigurationManager.AppSettings["LanguageCode"]));
}
if (engine == null)
{
engine = OcrEngine.TryCreateFromUserProfileLanguages();
}
var decoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(memoryRandomAccessStream);
OcrResult result = await engine.RecognizeAsync(await decoder.GetSoftwareBitmapAsync());
return(result.Text);
}
}
static async System.Threading.Tasks.Task Main(string[] args)
{
var loadResult = @".\lib_\loadResult.txt";
var language = new Language("ja");
if (!OcrEngine.IsLanguageSupported(language))
{
File.WriteAllText(loadResult, "False");
throw new Exception($"{ language.LanguageTag } is not supported in this system.");
}
else
{
File.WriteAllText(loadResult, "True");
}
var inputPath = @".\lib_\input.jpg";
var outputPath = @".\lib_\output.txt";
if (File.Exists(inputPath))
{
var stream = File.OpenRead(inputPath);
var decoder = await BitmapDecoder.CreateAsync(stream.AsRandomAccessStream());
var bitmap = await decoder.GetSoftwareBitmapAsync();
var engine = OcrEngine.TryCreateFromLanguage(language);
var ocrResult = await engine.RecognizeAsync(bitmap).AsTask();
Console.WriteLine(ocrResult.Text);
File.WriteAllText(outputPath, ocrResult.Text);
}
}
public MainPage()
{
this.InitializeComponent();
Language ocrLanguage = new Language("en");
ocrEngine = OcrEngine.TryCreateFromLanguage(ocrLanguage);
}
public async Task <List <string> > RecognizeAsync(List <StorageFile> pickedFiles)
{
List <string> results = new List <string>();
// OcrEngine engine = OcrEngine.TryCreateFromLanguage(new Windows.Globalization.Language("en-US"));
OcrEngine engine = OcrEngine.TryCreateFromLanguage(new Windows.Globalization.Language("pl"));
int i = 0;
foreach (StorageFile file in pickedFiles)
{
Informator.Log(" OCR - " + i + " out of " + pickedFiles.Count);
StringBuilder text = new StringBuilder();
var stream = await file.OpenAsync(FileAccessMode.Read);
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync();
OcrResult ocrResult = await engine.RecognizeAsync(softwareBitmap);
foreach (OcrLine line in ocrResult.Lines)
{
text.Append(line.Text + "\n");
}
results.Add(text.ToString());
i++;
}
return(results);
}
private void Setup(string ip)
{
if (this.requestHandlers == null)
{
this.requestHandlers = new Dictionary <string, Action <byte[]> >()
{
{ "/kinect/request/ocr", HandleRequestOCR },
{ "/kinect/request/webagent", HandleRequestWebAgent },
{ "/windows/alarm", HandleRequestAlarm }
};
}
if (this.client == null)
{
this.client = new MqttClient(ip);
this.client.ProtocolVersion = MqttProtocolVersion.Version_3_1;
this.client.MqttMsgPublishReceived += this.onMqttReceive;
this.client.Subscribe(this.requestHandlers.Keys.ToArray(), Enumerable.Repeat(MqttMsgBase.QOS_LEVEL_AT_LEAST_ONCE, this.requestHandlers.Count).ToArray());
this.client.Connect(Guid.NewGuid().ToString());
}
if (this.ocrEngine == null)
{
this.ocrEngine = new List <OcrEngine> {
};
var langLists = OcrEngine.AvailableRecognizerLanguages;
foreach (var lang in langLists)
{
ocrEngine.Add(OcrEngine.TryCreateFromLanguage(lang));
}
}
}
public static async Task <string> ExtractTextAsync(Image img, string lang)
{
MemoryStream memoryStream = new MemoryStream();
InMemoryRandomAccessStream randStream = new InMemoryRandomAccessStream();
string result = "";
try
{
img.Save(memoryStream, ImageFormat.Bmp);
await randStream.WriteAsync(memoryStream.ToArray().AsBuffer());
if (!OcrEngine.IsLanguageSupported(new Language(lang)))
{
Console.Write("This language is not supported!");
}
OcrEngine ocrEngine = OcrEngine.TryCreateFromLanguage(new Language(lang));
if (ocrEngine == null)
{
ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages();
}
var decoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(randStream);
OcrResult ocrResult = await ocrEngine.RecognizeAsync(await decoder.GetSoftwareBitmapAsync());
result = ocrResult.Text;
return(result);
}
finally
{
memoryStream.Dispose();
randStream.Dispose();
GC.Collect(0);
}
}
public static async Task <OcrResult?> GetOcrResultFromRegion(Rectangle region)
{
Language?selectedLanguage = GetOCRLanguage();
if (selectedLanguage == null)
{
return(null);
}
Bitmap bmp = new(region.Width, region.Height, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
Graphics g = Graphics.FromImage(bmp);
g.CopyFromScreen(region.Left, region.Top, 0, 0, bmp.Size, CopyPixelOperation.SourceCopy);
OcrResult?ocrResult;
await using (MemoryStream memory = new())
{
bmp.Save(memory, ImageFormat.Bmp);
memory.Position = 0;
BitmapDecoder bmpDecoder = await BitmapDecoder.CreateAsync(memory.AsRandomAccessStream());
SoftwareBitmap softwareBmp = await bmpDecoder.GetSoftwareBitmapAsync();
OcrEngine ocrEngine = OcrEngine.TryCreateFromLanguage(selectedLanguage);
ocrResult = await ocrEngine.RecognizeAsync(softwareBmp);
}
return(ocrResult);
}
public Form1()
{
InitializeComponent();
var engine = OcrEngine.TryCreateFromLanguage(new Windows.Globalization.Language("en-US"));
//string filePath = TestData.GetFilePath("testimage.png");
var file = Windows.Storage.StorageFile.GetFileFromPathAsync(@"C:\Cases\3333.jpg").GetAwaiter().GetResult();
var stream = file.OpenAsync(Windows.Storage.FileAccessMode.Read).GetAwaiter().GetResult();
var decoder = Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(stream).GetAwaiter().GetResult();
var softwareBitmap = decoder.GetSoftwareBitmapAsync().GetAwaiter().GetResult();
var ocrResult = engine.RecognizeAsync(softwareBitmap).GetAwaiter().GetResult();
List <OcrLine> lines = ocrResult.Lines.ToList();
StringBuilder sb = new StringBuilder();
foreach (var line in lines)
{
sb.Append(line.Text);
sb.Append("\n\n");
}
Console.WriteLine(sb.ToString());
//CreateDocument(words);
}
public MainPage()
{
InitializeComponent();
Loaded += MainPage_LoadedAsync;
// Init OCR engine with English language.
_ocrEngine = OcrEngine.TryCreateFromLanguage(new Language("en"));
}
public async Task prepoznajTablice()
{
await LoadSampleImage();
ocrEngine = OcrEngine.TryCreateFromLanguage(OcrEngine.AvailableRecognizerLanguages[0]);
var ocrResult = await ocrEngine.RecognizeAsync(bitmap);
rezultat = ocrResult.Text;
}
public MainPage()
{
this.InitializeComponent();
ocrEngine = OcrEngine.TryCreateFromLanguage(new Language("en"));
// Cache the UI to have the checkboxes retain their state, as the enabled/disabled state of the
// GetPreviewFrameButton is reset in code when suspending/navigating (see Start/StopPreviewAsync)
// Useful to know when to initialize/clean up the camera
}
public OcrDectection()
{
_ocrLanguage = new Language("nl");
if (!OcrEngine.IsLanguageSupported(_ocrLanguage))
{
throw new Exception($"OCR language {_ocrLanguage} not supported.");
}
_ocrEngine = OcrEngine.TryCreateFromLanguage(_ocrLanguage);
}
private async Task <OcrResultDisplay> ProcessImage(StorageFile file)
{
SoftwareBitmap bitmap;
ImageSource source;
using (var imgStream = await file.OpenAsync(FileAccessMode.Read))
{
var decoder = await BitmapDecoder.CreateAsync(imgStream);
bitmap = await decoder.GetSoftwareBitmapAsync();
}
if (bitmap == null)
{
source = new BitmapImage();
return(new OcrResultDisplay
{
OcrString = "No text found.\n",
OcrImage = source
});
}
OcrEngine engine = OcrEngine.TryCreateFromLanguage(new Windows.Globalization.Language("en"));
OcrResult result = await engine.RecognizeAsync(bitmap);
StringBuilder sb = new StringBuilder();
if (result.Lines == null)
{
source = new SoftwareBitmapSource();
bitmap = SoftwareBitmap.Convert(bitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
await((SoftwareBitmapSource)source).SetBitmapAsync(bitmap);
return(new OcrResultDisplay
{
OcrString = "No text found.\n",
OcrImage = source
});
}
foreach (var line in result.Lines)
{
foreach (var word in line.Words)
{
sb.Append(word.Text + " ");
}
sb.AppendLine();
}
source = new SoftwareBitmapSource();
bitmap = SoftwareBitmap.Convert(bitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
await((SoftwareBitmapSource)source).SetBitmapAsync(bitmap);
return(new OcrResultDisplay {
OcrString = sb.ToString(), OcrImage = source
});
}
public async Task <OcrResult> RecognizeText(Bitmap bmp)
{
var sbmp = await ConvertToSoftwareBitmap(bmp);
Windows.Globalization.Language language = new Windows.Globalization.Language("en");
OcrEngine ocrEngine = OcrEngine.TryCreateFromLanguage(language);
//OcrEngine ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages();
var ocrResult = await ocrEngine.RecognizeAsync(sbmp);
return(ocrResult);
}
private static async Task <string> OCRInternal(Bitmap bmp, string languageTag, bool singleLine = false)
{
Language language = new Language(languageTag);
if (!OcrEngine.IsLanguageSupported(language))
{
throw new Exception($"{language.DisplayName} language is not available in this system for OCR.");
}
OcrEngine engine = OcrEngine.TryCreateFromLanguage(language);
using (InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream())
{
bmp.Save(stream.AsStream(), ImageFormat.Bmp);
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
using (SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync())
{
OcrResult ocrResult = await engine.RecognizeAsync(softwareBitmap);
string separator;
if (singleLine)
{
separator = " ";
}
else
{
separator = Environment.NewLine;
}
if (language.LanguageTag.StartsWith("zh", StringComparison.OrdinalIgnoreCase) || // Chinese
language.LanguageTag.StartsWith("ja", StringComparison.OrdinalIgnoreCase) || // Japanese
language.LanguageTag.StartsWith("ko", StringComparison.OrdinalIgnoreCase)) // Korean
{
// If CJK language then remove spaces between words.
return(string.Join(separator, ocrResult.Lines.Select(line => string.Concat(line.Words.Select(word => word.Text)))));
}
else if (language.LayoutDirection == LanguageLayoutDirection.Rtl)
{
// If RTL language then reverse order of words.
return(string.Join(separator, ocrResult.Lines.Select(line => string.Join(" ", line.Words.Reverse().Select(word => word.Text)))));
}
else
{
return(string.Join(separator, ocrResult.Lines.Select(line => line.Text)));
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// METHODS //////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes the service by getting the desired language and trying to use it to create an
/// <see cref="OcrEngine"/>. If that fails, a default one is created instead.
/// </summary>
public void Initialize()
{
LogService?.Log.Information("AutoRotatorService: Initializing");
string desiredLanguageScript = (string)SettingsService.GetSetting(AppSetting.SettingAutoRotateLanguage);
Language desiredLanguage;
if (desiredLanguageScript != "")
{
desiredLanguage = new Language(desiredLanguageScript);
try
{
OcrEngine = OcrEngine.TryCreateFromLanguage(desiredLanguage);
}
catch (Exception)
{
}
}
if (OcrEngine == null)
{
// language unavailable, try to reset to default
OcrEngine = OcrEngine.TryCreateFromUserProfileLanguages();
if (OcrEngine == null)
{
// can not reset to default, try choosing a language
foreach (Language language in OcrEngine.AvailableRecognizerLanguages)
{
OcrEngine = OcrEngine.TryCreateFromLanguage(language);
if (OcrEngine != null)
{
break;
}
}
}
// language changed, update settings
if (OcrEngine != null)
{
SettingsService.SetSetting(AppSetting.SettingAutoRotateLanguage, OcrEngine.RecognizerLanguage.LanguageTag);
}
else
{
SettingsService.SetSetting(AppSetting.SettingAutoRotateLanguage, "");
}
}
}
private async Task <OcrResult> OcrMain(Bitmap bitmap, string baseLang)
{
OcrEngine ocrEngine = OcrEngine.TryCreateFromLanguage(new Language(baseLang));
MemoryStream ms = new MemoryStream();
bitmap.Save(ms, System.Drawing.Imaging.ImageFormat.Png);
var stream = await ConvertToRandomAccessStream(ms);
var bb = await LoadImage(stream);
var ocrResult = await ocrEngine.RecognizeAsync(bb);
return(ocrResult);
}
public CaptureEngine(IReadOnlyCollection <CaptureArea> captureAreas)
{
_captureAreas = captureAreas ?? throw new ArgumentNullException(nameof(captureAreas));
_timer = new DispatcherTimer {
Interval = TimeSpan.FromSeconds(1)
};
_timer.Tick += Timer_Tick;
foreach (var captureArea in _captureAreas.Where(cs => cs.IsEnabled))
{
_lastTimes.Add(captureArea, DateTime.MinValue);
}
_ocrEngine = OcrEngine.TryCreateFromLanguage(_language);
}
private async Task <string> GetStringFromImage(string filePath)
{
var engine = OcrEngine.TryCreateFromLanguage(new Windows.Globalization.Language("en-US"));
var file = await StorageFile.GetFileFromPathAsync(filePath);
var stream = await file.OpenAsync(FileAccessMode.Read);
var decoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(stream);
var softwareBitmap = await decoder.GetSoftwareBitmapAsync();
var ocrResult = await engine.RecognizeAsync(softwareBitmap);
return(ocrResult.Text);
}
static async Task <string> RecognizeAsync(string imagePath, string language)
{
StorageFile storageFile;
var path = Path.GetFullPath(imagePath); // x.png
var extName = Path.GetExtension(path); // .png
var outPath = path.Replace(extName, "") + "-out" + extName; // x-out.png
storageFile = await StorageFile.GetFileFromPathAsync(path);
IRandomAccessStream randomAccessStream = await storageFile.OpenReadAsync();
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(randomAccessStream);
SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
Globalization.Language lang = new Globalization.Language(language);
string space = language.Contains("zh") ? "" : " ";
string result = null;
if (OcrEngine.IsLanguageSupported(lang))
{
OcrEngine engine = OcrEngine.TryCreateFromLanguage(lang);
if (engine != null)
{
OcrResult ocrResult = await engine.RecognizeAsync(softwareBitmap);
foreach (var tempLine in ocrResult.Lines)
{
string line = "";
foreach (var word in tempLine.Words)
{
line += word.Text + space;
}
result += line + Environment.NewLine;
}
}
}
else
{
throw new Exception(string.Format("Language {0} is not supported", language));
};
randomAccessStream.Dispose();
softwareBitmap.Dispose();
return(await Task <string> .Run(() =>
{
return result;
}));
}
public async Task <(OCRPage, OctarineError, string)> GetTextFromStreamAsync(Stream istream)
{
var page = new OCRPage(System.Drawing.Image.FromStream(istream));
istream.Seek(0, SeekOrigin.Begin);
IRandomAccessStream stream = istream.AsRandomAccessStream();
if (!OcrEngine.IsLanguageSupported(language))
{
return(null, OctarineError.LanguageNotSupported, null);
}
try {
var engine = OcrEngine.TryCreateFromLanguage(language);
var decoder = await BitmapDecoder.CreateAsync(stream);
var softwareBitmap = await decoder.GetSoftwareBitmapAsync();
var ocrResult = await engine.RecognizeAsync(softwareBitmap);
foreach (OcrLine line in ocrResult.Lines)
{
string text = line.Text;
double x1 = -1, y1 = -1, x2 = -1, y2 = -1;
foreach (OcrWord word in line.Words)
{
if (x1 == -1 || x1 < word.BoundingRect.X)
{
x1 = word.BoundingRect.X;
}
if (y1 == -1 || y1 < word.BoundingRect.X)
{
y1 = word.BoundingRect.Y;
}
if (x2 == -1 || x2 > word.BoundingRect.X + word.BoundingRect.Width)
{
x2 = word.BoundingRect.X + word.BoundingRect.Width;
}
if (y2 == -1 || y2 > word.BoundingRect.Y + word.BoundingRect.Height)
{
y2 = word.BoundingRect.Y + word.BoundingRect.Height;
}
}
page.AddFragment(text, (int)x1, (int)y1, (int)(x2 - x1), (int)(y2 - y1));
}
return(page, OctarineError.Success, null);
} catch (Exception ex) { return(null, OctarineError.EngineError, ex.Message); }
}
public override PageRect OcrAnalyze(Stream stream)
{
var createAsyncTask = BitmapDecoder.CreateAsync(stream.AsRandomAccessStream()).AsTask();
createAsyncTask.Wait();
var bitmapDecoder = createAsyncTask.Result;
var getSoftwareBitmapAsyncTask = bitmapDecoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Premultiplied).AsTask();
getSoftwareBitmapAsyncTask.Wait();
SoftwareBitmap softwareBitmap = getSoftwareBitmapAsyncTask.Result;
IReadOnlyList <Language> langList = OcrEngine.AvailableRecognizerLanguages;
var ocrEngine = OcrEngine.TryCreateFromLanguage(langList[0]);
var recognizeAsyncTask = ocrEngine.RecognizeAsync(softwareBitmap).AsTask();
recognizeAsyncTask.Wait();
var ocrResult = recognizeAsyncTask.Result;
var lineRects = ocrResult.Lines.SelectMany(ocrLine =>
{
return(ocrLine.Words.Select(word =>
{
return new LineText
{
Height = (int)word.BoundingRect.Height,
Width = (int)word.BoundingRect.Width,
Top = (int)word.BoundingRect.Top,
Left = (int)word.BoundingRect.Left,
X = (int)word.BoundingRect.X,
Y = (int)word.BoundingRect.Y,
Text = word.Text,
FontSize = word.BoundingRect.Height >= word.BoundingRect.Width ? (int)word.BoundingRect.Height : (int)word.BoundingRect.Width
};
}));
}).ToList();
return(new PageRect
{
Height = softwareBitmap.PixelHeight,
Width = softwareBitmap.PixelWidth,
LineTexts = lineRects
});
}
static string RunOcrTests(string language, string file, bool spacing, bool newLines)
{
Language lang = null;
foreach (Language ocrLanguage in OcrEngine.AvailableRecognizerLanguages)
{
if (ocrLanguage.LanguageTag.Equals(language, StringComparison.OrdinalIgnoreCase))
{
lang = ocrLanguage;
}
}
if (lang == null)
{
return(null);
}
using (var image = (System.Drawing.Bitmap)System.Drawing.Bitmap.FromFile(file))
{
IBuffer buffer = WindowsRuntimeBufferExtensions.AsBuffer(BitmapToByteArray(image));
using (SoftwareBitmap bitmap = SoftwareBitmap.CreateCopyFromBuffer(buffer, BitmapPixelFormat.Rgba8, image.Width, image.Height))
{
OcrEngine engine = OcrEngine.TryCreateFromLanguage(lang);
var result = engine.RecognizeAsync(bitmap);
Task.WaitAll(result.AsTask <OcrResult>());
string extractedText = string.Empty;
OcrResult ocrResult = result.GetResults();
if (ocrResult != null && ocrResult.Lines != null)
{
foreach (OcrLine line in ocrResult.Lines)
{
foreach (OcrWord word in line.Words)
{
extractedText += word.Text + (spacing ? " " : string.Empty);
}
extractedText = extractedText.TrimEnd();
if (newLines)
{
extractedText += Environment.NewLine;
}
}
}
return(extractedText.TrimEnd());
}
}
}
