private async void clickDetect(object sender, RoutedEventArgs e)
{
var ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages();
var ocrResult = await ocrEngine.RecognizeAsync(bitmap);
text1.Text = ocrResult.Text;
}
private async void ClickButtonMakePhoto(object sender, RoutedEventArgs e)
{
CameraCaptureUI captureUI = new CameraCaptureUI();
captureUI.PhotoSettings.Format = CameraCaptureUIPhotoFormat.Jpeg;
StorageFile photo = await captureUI.CaptureFileAsync(CameraCaptureUIMode.Photo);
if (photo == null)
{
return;
}
IRandomAccessStream stream = await photo.OpenAsync(FileAccessMode.Read);
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
SoftwareBitmap bitmap = await decoder.GetSoftwareBitmapAsync();
Language ocrLanguage = new Language("en");
OcrEngine ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages();
OcrResult ocrResult = await ocrEngine.RecognizeAsync(bitmap);
string result = ocrResult.Text;
Frame.Navigate(typeof(SelectTextAppoinmentPage), result);
}
private async void ClickBottonBrowse(object sender, RoutedEventArgs e)
{
FileOpenPicker fileOpenPicker = new FileOpenPicker();
fileOpenPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
fileOpenPicker.FileTypeFilter.Add(".jpg");
fileOpenPicker.ViewMode = PickerViewMode.Thumbnail;
var inputFile = await fileOpenPicker.PickSingleFileAsync();
if (inputFile == null)
{
return;
}
SoftwareBitmap bitmap;
using (IRandomAccessStream stream = await inputFile.OpenAsync(FileAccessMode.Read))
{
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
bitmap = await decoder.GetSoftwareBitmapAsync();
}
Language ocrLanguage = new Language("en");
OcrEngine ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages();
OcrResult ocrResult = await ocrEngine.RecognizeAsync(bitmap);
string result = ocrResult.Text;
Frame.Navigate(typeof(SelectTextAppoinmentPage), result);
}
private async void GetOCRAsync(SoftwareBitmap inputBitmap)
{
if (_ocrRunning)
{
return;
}
_ocrRunning = true;
SoftwareBitmap localBitmap = SoftwareBitmap.Copy(inputBitmap);
var ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages();
var recognizeAsync = await ocrEngine.RecognizeAsync(localBitmap);
var str = new StringBuilder();
foreach (var ocrLine in recognizeAsync.Lines)
{
str.AppendLine(ocrLine.Text);
}
var readText = str.ToString();
if (readText != "")
{
WinOCRResult = readText;
}
_ocrRunning = false;
return;
}
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);
}
}
public async Task <List <string> > ProcessImage(string image)
{
List <string> result = new List <string>();
BitmapDecoder bmpDecoder;
SoftwareBitmap softwareBmp;
OcrEngine ocrEngine;
OcrResult ocrResult;
try
{
await using (var fileStream = File.OpenRead(image))
{
bmpDecoder = await BitmapDecoder.CreateAsync(fileStream.AsRandomAccessStream());
softwareBmp = await bmpDecoder.GetSoftwareBitmapAsync();
ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages();
ocrResult = await ocrEngine.RecognizeAsync(softwareBmp);
foreach (var line in ocrResult.Lines)
{
result.Add(line.Text);
}
}
}
catch (Exception ex)
{
throw (ex);
}
return(result);
}
public static IServiceCollection AddCoreServices(this IServiceCollection services, CancellationToken token, Type replayProvider)
{
var configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json")
.AddEnvironmentVariables("HEROES_REPLAY_")
.Build();
var focusCalculator = typeof(IFocusCalculator);
var calculators = focusCalculator.Assembly.GetTypes().Where(type => type.IsClass && focusCalculator.IsAssignableFrom(type));
foreach (var calculatorType in calculators)
{
services.AddSingleton(focusCalculator, calculatorType);
}
var settings = configuration.Get <Settings>();
return(services
.AddLogging(builder => builder.AddConfiguration(configuration.GetSection("Logging")).AddConsole().AddEventLog(config => config.SourceName = "Heroes Replay"))
.AddSingleton <IConfiguration>(configuration)
.AddSingleton(settings)
.AddSingleton(new CancellationTokenProvider(token))
.AddSingleton(OcrEngine.TryCreateFromUserProfileLanguages())
.AddSingleton(typeof(CaptureStrategy), settings.Capture.Method switch { CaptureMethod.None => typeof(CaptureStub), CaptureMethod.BitBlt => typeof(CaptureBitBlt), CaptureMethod.CopyFromScreen => typeof(CaptureFromScreen), _ => typeof(CaptureBitBlt) })
/// <summary>
/// Extracts text from an image using Windows 10 OCR.
/// The extraction is done using a machine's active preferred language.
/// </summary>
/// <param name="image">The image to extract text from.</param>
/// <returns>The text extracted from an image.</returns>
public async Task <string> ExtractText(string image)
{
if (string.IsNullOrWhiteSpace(image))
{
throw new ArgumentNullException("Image can't be null or empty.");
}
if (!File.Exists(image))
{
throw new ArgumentOutOfRangeException($"'{image}' doesn't exist.");
}
CheckIfFileIsImage(image);
StringBuilder text = new StringBuilder();
await using (var fileStream = File.OpenRead(image))
{
var bmpDecoder = await BitmapDecoder.CreateAsync(fileStream.AsRandomAccessStream());
var softwareBmp = await bmpDecoder.GetSoftwareBitmapAsync();
var ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages();
var ocrResult = await ocrEngine.RecognizeAsync(softwareBmp);
foreach (var line in ocrResult.Lines)
{
text.AppendLine(line.Text);
}
}
return(text.ToString());
}
public async Task <string> Run()
{
foreach (string argument in arguments)
{
if (!System.IO.File.Exists(argument))
{
continue;
}
System.IO.FileInfo info = new System.IO.FileInfo(argument);
if (!info.Exists)
{
continue;
}
StorageFile file = await StorageFile.GetFileFromPathAsync(info.FullName);
IRandomAccessStreamWithContentType stream = await file.OpenReadAsync();
var decoder = await BitmapDecoder.CreateAsync(stream);
SoftwareBitmap image = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Premultiplied);
OcrEngine engine = OcrEngine.TryCreateFromUserProfileLanguages();
OcrResult result = await engine.RecognizeAsync(image);
Console.WriteLine(result.Text);
return(result.Text);
}
return(null);
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
setLanguageList();
bool hasCamera = await setCameraListAsync();
if (hasCamera)
{
await InitializeMediaCaptureAsync();
}
return;
#region local functions in OnNavigatedTo
void setLanguageList()
{
// サポート言語の一覧を得る
IReadOnlyList <Language> langList = OcrEngine.AvailableRecognizerLanguages;
// コンボボックスにサポート言語の一覧を表示する
this.LangComboBox.ItemsSource = langList;
// 選択肢として表示するのはDisplayNameプロパティ（「日本語」など）
this.LangComboBox.DisplayMemberPath = nameof(Windows.Globalization.Language.DisplayName);
// SelectedValueとしてLanguageTagプロパティを使う（「ja」など）
this.LangComboBox.SelectedValuePath = nameof(Windows.Globalization.Language.LanguageTag);
// ユーザープロファイルに基いてOCRエンジンを作ってみる
var ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages();
// その認識言語をコンボボックスで選択状態にする
this.LangComboBox.SelectedValue = ocrEngine.RecognizerLanguage.LanguageTag;
}
async Task <bool> setCameraListAsync()
{
var devices = await DeviceInformation.FindAllAsync(DeviceClass.VideoCapture);
if (devices.Count == 0)
{
HideCameraUI();
return(false);
}
setupCameraComboBox(devices);
return(true);
void setupCameraComboBox(IReadOnlyList <DeviceInformation> deviceList)
{
this.CameraComboBox.ItemsSource = deviceList;
this.CameraComboBox.DisplayMemberPath = nameof(DeviceInformation.Name);
this.CameraComboBox.SelectedValuePath = nameof(DeviceInformation.Id);
this.CameraComboBox.SelectedIndex = 0;
}
}
#endregion
} // OnNavigatedTo
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);
}
}
/// <summary>
/// Microsoft OCR の呼び出し
/// </summary>
/// <param name="bitmap"></param>
/// <returns></returns>
public async Task <OcrResult> detect(SoftwareBitmap bitmap)
{
var ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages();
var ocrResult = await ocrEngine.RecognizeAsync(bitmap);
return(ocrResult);
}
public async Task <string> BmpToString(SoftwareBitmap bitmap)
{
var ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages();
var ocrResult = await ocrEngine.RecognizeAsync(bitmap);
return(ocrResult.Text);
}
public async Task ExtractWords()
{
OcrEngine ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages();
if (ocrEngine != null)
{
foreach (var pdfPage in PdfPages)
{
if (pdfPage.Image.PixelWidth > OcrEngine.MaxImageDimension || pdfPage.Image.PixelHeight > OcrEngine.MaxImageDimension)
{
return;
}
var ocrResult = await ocrEngine.RecognizeAsync(pdfPage.Image);
foreach (var line in ocrResult.Lines)
{
foreach (var word in line.Words)
{
pdfPage.Words.Add(word);
}
}
}
}
}
private async Task <OcrResult> OcrMain(string filename)
{
OcrEngine ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages();
var bitmap = await LoadImage(filename);
var ocrResult = await ocrEngine.RecognizeAsync(bitmap);
return(ocrResult);
}
public static async Task <Image <Bgr, byte> > CaptureSubImageTest2()
{
var capture = new Capture
{
OcrEngine = OcrEngine.TryCreateFromUserProfileLanguages(),
Screen = new Screen()
};
return(await capture.TestImageMatch2());
}
public static async Task <SoftwareBitmap> TestCaptureZombidle()
{
OcrEngine ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages();
// If no engine, return void.
if (ocrEngine == null)
{
return(null);
}
var screen = new Screen();
var bitmap = await screen.GetBitmap();
var softwarebitmap = await bitmap.ToBitmapImage().ToSoftwareBitmap();
var ocrResult = await ocrEngine.RecognizeAsync(softwarebitmap);
Logging.Log(ocrResult.Text);
return(softwarebitmap);
}
/**
* OCRを実行する
*/
private async Task <string> RecognizeText(int pattern)
{
OcrEngine ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages();
SoftwareBitmap snap = await screenCapture.GetSoftwareSnapShot(pattern);
var ocrResult = await ocrEngine.RecognizeAsync(snap);
string ocrText = ocrResult.Text;
return(ocrText);
}
public static async void CaptureZombidleWindowTest3(int iterations = 20, int delay = 250)
{
var capture = new Capture
{
OcrEngine = OcrEngine.TryCreateFromUserProfileLanguages(),
Screen = new Screen()
};
for (var i = 1; i <= iterations; i++)
{
Logging.Log($"Count: {i}");
await capture.TestCaptureZombidle3();
}
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
picker.FileTypeFilter.Add(".jpg");
picker.FileTypeFilter.Add(".jpeg");
picker.FileTypeFilter.Add(".png");
// Open a stream for the selected file
StorageFile file = await picker.PickSingleFileAsync();
// Ensure a file was selected
if (file != null)
{
using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read))
{
// Set the image source to the selected bitmap
BitmapImage bitmapImage = new BitmapImage();
bitmapImage.DecodePixelWidth = 600; //match the target Image.Width, not shown
await bitmapImage.SetSourceAsync(fileStream);
MyImage.Source = bitmapImage;
}
SoftwareBitmap softwareBitmap;
using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read))
{
// Create the decoder from the stream
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
// Get the SoftwareBitmap representation of the file
softwareBitmap = await decoder.GetSoftwareBitmapAsync();
var Engine = OcrEngine.TryCreateFromUserProfileLanguages();
var result = await Engine.RecognizeAsync(softwareBitmap);
Debug.WriteLine(result.Lines);
Debug.WriteLine(result.Text);
foreach (var line in result.Lines)
{
foreach (var text in line.Words)
{
Debug.WriteLine(text.Text);
}
}
}
}
}
public static string ImageToText(Bitmap screenBitmap)
{
var task = Task.Run <OcrResult>(async() =>
{
var ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages();
var minScreenBitmap = new Bitmap(Math.Max(100, screenBitmap.Width), Math.Max(100, screenBitmap.Height));
Graphics.FromImage(minScreenBitmap).DrawImage(screenBitmap, Point.Empty);
var softwareBitmap = await GetSoftwareBitmapFromBitmap(minScreenBitmap);
return(await ocrEngine.RecognizeAsync(softwareBitmap));
});
task.Wait();
return(task.Result.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 void Button_Click(object sender, RoutedEventArgs e)
{
// string filePath = Path.GetFullPath(@"\Users\Jsquared\Desktop\SS\screenshot_20180401204846.jpeg");
FolderPicker picker1 = new FolderPicker()
{
SuggestedStartLocation = PickerLocationId.PicturesLibrary
};
picker1.FileTypeFilter.Add(".jpg");
picker1.FileTypeFilter.Add(".jpeg");
StorageFolder folder = await picker1.PickSingleFolderAsync();
// Get the first 20 files in the current folder, sorted by date.
IReadOnlyList <StorageFile> sortedItems = await folder.GetFilesAsync();
// Iterate over the results and print the list of files
// to the Visual Studio Output window.
foreach (StorageFile file1 in sortedItems)
{
Debug.WriteLine(file1.Name + ", " + file1.DateCreated);
}
var picker = new FileOpenPicker();
picker.ViewMode = PickerViewMode.Thumbnail;
picker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
picker.FileTypeFilter.Add(".jpg");
picker.FileTypeFilter.Add(".jpeg");
picker.FileTypeFilter.Add(".png");
StorageFile file = await picker.PickSingleFileAsync();
// var file = await StorageFile.GetFileFromPathAsync("screenshot_20180401205136.jpeg");
var stream = await file.OpenAsync(FileAccessMode.Read);
var decoder = await BitmapDecoder.CreateAsync(stream);
var softwareBitmap = await decoder.GetSoftwareBitmapAsync();
OcrEngine ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages();
OcrResult ocrResult = await ocrEngine.RecognizeAsync(softwareBitmap);
string extractedText = ocrResult.Text;
textbox1.Text = ocrResult.Text;
}
private static async Task <string> RunOcr(IRandomAccessStream stream)
{
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(stream);
var result = await engine.RecognizeAsync(await decoder.GetSoftwareBitmapAsync());
return(result.Text);
}
/// <summary>
/// Run the Windows 10 OCR engine to process the text on the captured image
/// </summary>
/// <param name="manuallyInitiated"></param>
/// <param name="surface"></param>
/// <param name="captureDetails"></param>
/// <returns>ExportInformation</returns>
public override async Task <ExportInformation> ExportCaptureAsync(bool manuallyInitiated, ISurface surface, ICaptureDetails captureDetails)
{
var exportInformation = new ExportInformation(Designation, Description);
try
{
string text;
var ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages();
using (var imageStream = new MemoryStream())
{
ImageOutput.SaveToStream(surface, imageStream, new SurfaceOutputSettings());
imageStream.Position = 0;
var decoder = await BitmapDecoder.CreateAsync(imageStream.AsRandomAccessStream());
var softwareBitmap = await decoder.GetSoftwareBitmapAsync();
var ocrResult = await ocrEngine.RecognizeAsync(softwareBitmap);
text = ocrResult.Text;
}
// Check if we found text
if (!string.IsNullOrWhiteSpace(text))
{
// Place the OCR text on the clipboard
using (var clipboardAccessToken = ClipboardNative.Access())
{
clipboardAccessToken.ClearContents();
clipboardAccessToken.SetAsUnicodeString(text);
}
}
exportInformation.ExportMade = true;
}
catch (Exception ex)
{
exportInformation.ExportMade = false;
exportInformation.ErrorMessage = ex.Message;
}
ProcessExport(exportInformation, surface);
return(exportInformation);
}
/// <summary>
/// Perform optical character recognition.
/// </summary>
public override void Recognize()
{
if (_isRecognizing)
{
return;
}
_isRecognizing = true;
var item = new AppCallbackItem(async() =>
{
var previewProperties =
_mediaCapture.VideoDeviceController.GetMediaStreamProperties(MediaStreamType.VideoPreview)
as VideoEncodingProperties;
if (previewProperties == null)
{
return;
}
var videoFrame = new VideoFrame(BitmapPixelFormat.Rgba8, (int)previewProperties.Width,
(int)previewProperties.Height);
_videoFrame = await _mediaCapture.GetPreviewFrameAsync(videoFrame);
var ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages();
if (ocrEngine == null)
{
return;
}
var recognizeAsync = await ocrEngine.RecognizeAsync(_videoFrame.SoftwareBitmap);
var str = new StringBuilder();
foreach (var ocrLine in recognizeAsync.Lines)
{
str.AppendLine(ocrLine.Text);
}
var recoginzeText = str.ToString();
_isRecognizing = false;
if (OnRecognized != null)
{
AppCallbacks.Instance.InvokeOnAppThread(() => { OnRecognized(recoginzeText); }, false);
}
});
AppCallbacks.Instance.InvokeOnUIThread(item, false);
}
protected override async Task <bool> ProcessFrameAsync(MediaFrameReference frameReference)
{
bool done = false;
// doc here https://msdn.microsoft.com/en-us/library/windows/apps/xaml/windows.media.capture.frames.videomediaframe.aspx
// says to dispose this softwarebitmap if you access it.
using (var bitmap = frameReference.VideoMediaFrame.SoftwareBitmap)
{
try
{
if (this.ocrEngine == null)
{
this.ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages();
this.regex = new Regex(IP_ADDRESS_PATTERN);
}
var results = await this.ocrEngine.RecognizeAsync(bitmap);
if (results != null)
{
var matchingResults = this.regex.Matches(results.Text);
for (int i = 0; !done && (i < matchingResults.Count); i++)
{
IPAddress parsedAddress;
done = IPAddress.TryParse(matchingResults[i].Value, out parsedAddress);
if (done)
{
this.Result = parsedAddress;
}
}
}
}
catch
{
}
}
return(done);
}
private async void buttonAddPrice_Click(object sender, RoutedEventArgs e)
{
CameraCaptureUI captureUI = new CameraCaptureUI();
captureUI.PhotoSettings.Format = CameraCaptureUIPhotoFormat.Jpeg;
//captureUI.PhotoSettings.CroppedSizeInPixels = new Size(300, 300);
StorageFile photo = await captureUI.CaptureFileAsync(CameraCaptureUIMode.Photo);
if (photo == null)
{
// User cancelled photo capture
return;
}
SoftwareBitmap bitmapa = null;
OcrEngine silnik = OcrEngine.TryCreateFromUserProfileLanguages();
using (var stream = await photo.OpenAsync(Windows.Storage.FileAccessMode.Read))
{
var decoder = await BitmapDecoder.CreateAsync(stream);
bitmapa = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
}
OcrResult rezultat = await silnik.RecognizeAsync(bitmapa);
try
{
price = ParsePrice(rezultat.Text);
this.Frame.Navigate(typeof(AddPrice));
}
catch (Exception exception)
{
MessageDialog message = new MessageDialog(exception.ToString() + "\n Sparsowny text: " + rezultat.Text);
await message.ShowAsync();
}
//textBlock.Text = rezultat.Text;
}
public async void SetOcr(SnapShot SelectedSnapShot)
{
var ocr = OcrEngine.TryCreateFromUserProfileLanguages();
var storageFile = await StorageFile.GetFileFromPathAsync(SelectedSnapShot.MaxQualityOutput.File.FullName);
SoftwareBitmap softwareBitmap;
using (IRandomAccessStream stream = await storageFile.OpenAsync(FileAccessMode.Read))
{
// Create the decoder from the stream
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
// Get the SoftwareBitmap representation of the file
softwareBitmap = await decoder.GetSoftwareBitmapAsync();
var result = await ocr.RecognizeAsync(softwareBitmap);
// Check whether text is detected.
if (result.Lines != null)
{
// Collect recognized text.
string recognizedText = "";
foreach (var line in result.Lines)
{
foreach (var word in line.Words)
{
recognizedText += word.Text + " ";
}
recognizedText += Environment.NewLine;
}
// Display recognized text.
OcrTextBox.Text = recognizedText;
}
}
}
private void Form1_Load(object sender, EventArgs e)
{
ocr = OcrEngine.TryCreateFromUserProfileLanguages();
LoadEnemies();
int enemyCaptureX = 395;
int enemyCaptureY = 690;
int enemyCaptureWidth = 360;
int enemyCaptureHeight = 210;
txtEnemyCaptureX.Text = enemyCaptureX.ToString();
txtEnemyCaptureY.Text = enemyCaptureY.ToString();
txtEnemyCaptureWidth.Text = enemyCaptureWidth.ToString();
txtEnemyCaptureHeight.Text = enemyCaptureHeight.ToString();
enemyData = new DataCapture("enemy", enemyCaptureX, enemyCaptureY, enemyCaptureWidth, enemyCaptureHeight, pbEnemyCapture, lblEnemyCaptureStatus);
int itemCaptureX = 450;
int itemCaptureY = 110;
int itemCaptureWidth = 600;
int itemCaptureHeight = 210;
txtItemCaptureX.Text = itemCaptureX.ToString();
txtItemCaptureY.Text = itemCaptureY.ToString();
txtItemCaptureWidth.Text = itemCaptureWidth.ToString();
txtItemCaptureHeight.Text = itemCaptureHeight.ToString();
itemData = new DataCapture("item", itemCaptureX, itemCaptureY, itemCaptureWidth, itemCaptureHeight, pbItemCapture, lblItemCaptureStatus);
//LoadExtraData();
//XDocument doc = XDocument.Load(@"ffiv_enemies.xml");
//foreach (XElement eTable in doc.Root.Elements("table")) {
// Enemy enemy = new Enemy(eTable);
// Enemies.Add(enemy);
//}
}
