private static async void AnalyzeImage(string filePath)
{
string url;
var client = new VisionServiceClient(SubscriptionKey);
using (Stream imageFileStream = File.OpenRead(filePath))
{
var resultHw = await client.CreateHandwritingRecognitionOperationAsync(imageFileStream);
url = resultHw.Url;
}
var operation = new HandwritingRecognitionOperation {
Url = url
};
var result = await client.GetHandwritingRecognitionOperationResultAsync(operation);
foreach (var line in result.RecognitionResult.Lines)
{
foreach (var word in line.Words)
{
Console.WriteLine(word.Text);
}
}
}
public async Task GetHandwriting(string text)
{
HandwritingRecognitionOperation operation = new HandwritingRecognitionOperation();
operation.Url = text;
Resultado.Text = "";
// Call the Vision API.
try
{
var result = await _visionServiceClient.GetHandwritingRecognitionOperationResultAsync(operation);
foreach (var line in result.RecognitionResult.Lines)
{
foreach (var word in line.Words)
{
Resultado.Text += word.Text + " ";
}
}
}
// Catch and display Vision API errors.
catch (ClientException c)
{
await DisplayAlert("Error", c.Message, "ok");
}
// Catch and display all other errors.
catch (Exception e)
{
await DisplayAlert("Error", e.Message, "ok");
}
}
private async Task<HandwritingRecognitionOperationResult> HandwritingRecognitionTask(Func<VisionServiceClient, Task<HandwritingRecognitionOperation>> Func)
{
int MaxRetryTimes = 3;
HandwritingRecognitionOperationResult result;
try
{
HandwritingRecognitionOperation operation = await Func(visionClient);
result = await visionClient.GetHandwritingRecognitionOperationResultAsync(operation);
int i = 0;
while ((result.Status == HandwritingRecognitionOperationStatus.Running || result.Status == HandwritingRecognitionOperationStatus.NotStarted) && i++ < MaxRetryTimes)
{
result = await visionClient.GetHandwritingRecognitionOperationResultAsync(operation);
}
}
catch (ClientException ex)
{
result = new HandwritingRecognitionOperationResult() { Status = HandwritingRecognitionOperationStatus.Failed };
}
return result;
}
private static async Task <string[]> TextExtractionCore(string fname, bool wrds, string method)
{
VisionServiceClient vsClient = new VisionServiceClient(API_Key, API_Location);
string[] textres = null;
if (System.IO.File.Exists(fname))
{
using (Stream stream = System.IO.File.OpenRead(fname))
{
switch (method)
{
case "TextPic":
OcrResults ocr = await vsClient.RecognizeTextAsync(stream, "unk", false);
textres = GetExtracted(ocr, wrds);
break;
case "HandwrittenPic":
HandwritingRecognitionOperation hdro = await vsClient.CreateHandwritingRecognitionOperationAsync(stream);
HandwritingRecognitionOperationResult hresult = await vsClient.GetHandwritingRecognitionOperationResultAsync(hdro);
textres = GetHandWrittenExtracted(hresult, wrds);
break;
}
}
}
return(textres);
}
public async Task <ActionResult> Index()
{
if (Request.HttpMethod == "GET")
{
return(View());
}
var model = new HandwritingModel();
HandwritingRecognitionOperation op = null;
await RunOperationOnImage(async stream =>
{
op = await VisionServiceClient.CreateHandwritingRecognitionOperationAsync(stream);
});
while (true)
{
await Task.Delay(5000);
var result = await VisionServiceClient.GetHandwritingRecognitionOperationResultAsync(op);
if (result.Status == HandwritingRecognitionOperationStatus.NotStarted ||
result.Status == HandwritingRecognitionOperationStatus.Running)
{
continue;
}
model.Result = result.RecognitionResult;
break;
}
model.ImageDump = GetInlineImageWithLines(model.Result);
return(View(model));
}
/// <summary>
/// Performs Azure Cognitive Services Handwritten Text Recognition on image
/// </summary>
/// <param name="image">Image byte array</param>
/// <returns>Condensed text string with OCR results</returns>
private async Task <string> HandwrittenTextRecognition(byte[] image)
{
var client = AzureCognitiveServicesApiUrl == string.Empty ?
new VisionServiceClient(AzureCognitiveServicesKey) :
new VisionServiceClient(AzureCognitiveServicesKey, AzureCognitiveServicesApiUrl);
HandwritingRecognitionOperation hwResult = null;
using (var photoStream = new MemoryStream(image))
hwResult = await client.CreateHandwritingRecognitionOperationAsync(photoStream);
var timeout = new Stopwatch();
timeout.Start();
HandwritingRecognitionOperationResult response;
do
{
//iteration interval
var waitInterval = new Stopwatch();
waitInterval.Start();
while (waitInterval.Elapsed.TotalMilliseconds < AzureHandwrittenRecognitionInterval) /*wait*/ } {
waitInterval.Stop();
response = await client.GetHandwritingRecognitionOperationResultAsync(hwResult);
}while (timeout.Elapsed.TotalMilliseconds < AzureHandwrittenRecognitionTimeout &&
response.Status == HandwritingRecognitionOperationStatus.Running);
if (timeout.Elapsed.TotalMilliseconds == AzureHandwrittenRecognitionTimeout &&
response.Status == HandwritingRecognitionOperationStatus.Running)
{
return(string.Empty);
}
timeout.Stop();
if (response.Status == HandwritingRecognitionOperationStatus.Succeeded)
{
var condensedText = string.Empty;
foreach (var l in response.RecognitionResult.Lines)
{
foreach (var w in l.Words)
{
condensedText += w.Text;
}
}
condensedText = condensedText.ToLower();
return(condensedText);
}
else
{
return(string.Empty);
}
}
private async Task <HandwritingRecognitionOperationResult> RecognizeAsync(Func <VisionServiceClient, Task <HandwritingRecognitionOperation> > Func)
{
// -----------------------------------------------------------------------
// KEY SAMPLE CODE STARTS HERE
// -----------------------------------------------------------------------
//
// Create Project Oxford Vision API Service client
//
VisionServiceClient VisionServiceClient = new VisionServiceClient(SubscriptionKey); //, "https://westcentralus.api.cognitive.microsoft.com/vision/v1.0");
Log("VisionServiceClient is created");
HandwritingRecognitionOperationResult result;
try
{
Log("Calling VisionServiceClient.CreateHandwritingRecognitionOperationAsync()...");
HandwritingRecognitionOperation operation = await Func(VisionServiceClient);
Log("Calling VisionServiceClient.GetHandwritingRecognitionOperationResultAsync()...");
result = await VisionServiceClient.GetHandwritingRecognitionOperationResultAsync(operation);
int i = 0;
while ((result.Status == HandwritingRecognitionOperationStatus.Running || result.Status == HandwritingRecognitionOperationStatus.NotStarted) && i++ < MaxRetryTimes)
{
Log(string.Format("Server status: {0}, wait {1} seconds...", result.Status, QueryWaitTimeInSecond));
await Task.Delay(QueryWaitTimeInSecond);
Log("Calling VisionServiceClient.GetHandwritingRecognitionOperationResultAsync()...");
result = await VisionServiceClient.GetHandwritingRecognitionOperationResultAsync(operation);
}
}
catch (ClientException ex)
{
result = new HandwritingRecognitionOperationResult()
{
Status = HandwritingRecognitionOperationStatus.Failed
};
Log(ex.Error.Message);
}
return(result);
// -----------------------------------------------------------------------
// KEY SAMPLE CODE ENDS HERE
// -----------------------------------------------------------------------
}
public static async Task <string[]> HandwritingExtractionCore(string fname, bool wrds)
{
VisionServiceClient client = new VisionServiceClient(API_key, API_location);
string[] textres = null;
if (File.Exists(fname))
{
using (Stream stream = File.OpenRead(fname))
{
HandwritingRecognitionOperation op = await client.CreateHandwritingRecognitionOperationAsync(stream);
HandwritingRecognitionOperationResult res = await client.GetHandwritingRecognitionOperationResultAsync(op);
textres = GetExtracted(res, wrds);
}
}
return(textres);
}
public async Task GetHandwriting(string text)
{
HandwritingRecognitionOperation operation = new HandwritingRecognitionOperation();
operation.Url = text;
resultado = "";
// Call the Vision API.
try
{
var result = await _visionServiceClient.GetHandwritingRecognitionOperationResultAsync(operation);
foreach (var line in result.RecognitionResult.Lines)
{
foreach (var word in line.Words)
{
resultado += word.Text + " ";
}
}
if (!String.IsNullOrWhiteSpace(resultado))
{
await Navigation.PushAsync(new Detalhe(resultado));
}
else
{
await DisplayAlert("", "Nenhum texto encontrado :(", "OK");
}
}
// Catch and display Vision API errors.
catch (ClientException c)
{
await DisplayAlert("Error", c.Message, "ok");
}
// Catch and display all other errors.
catch (Exception e)
{
await DisplayAlert("Error", "Ops... Algo deu errado na análise da imagem. :( ", "OK");
}
}
private async Task <HandwritingRecognitionOperationResult> RecognizeAsync(Func <Task <HandwritingRecognitionOperation> > Func)
{
// -----------------------------------------------------------------------
// KEY SAMPLE CODE STARTS HERE
// -----------------------------------------------------------------------
//
// Create Project Oxford Vision API Service client
//
HandwritingRecognitionOperationResult result;
try
{
HandwritingRecognitionOperation operation = await Func();
result = await visionServiceClient.GetHandwritingRecognitionOperationResultAsync(operation);
int i = 0;
while ((result.Status == HandwritingRecognitionOperationStatus.Running || result.Status == HandwritingRecognitionOperationStatus.NotStarted) && i++ < MaxRetryTimes)
{
await Task.Delay(QueryWaitTimeInSecond);
result = await visionServiceClient.GetHandwritingRecognitionOperationResultAsync(operation);
}
}
catch (ClientException)
{
result = new HandwritingRecognitionOperationResult()
{
Status = HandwritingRecognitionOperationStatus.Failed
};
}
return(result);
// -----------------------------------------------------------------------
// KEY SAMPLE CODE ENDS HERE
// -----------------------------------------------------------------------
}
/// <summary>
/// Get HandwritingRecognitionOperationResult
/// </summary>
/// <param name="opeartion">HandwritingRecognitionOperation object</param>
/// <returns>HandwritingRecognitionOperationResult</returns>
public async Task <HandwritingRecognitionOperationResult> GetHandwritingRecognitionOperationResultAsync(HandwritingRecognitionOperation opeartion)
{
string requestUrl = string.Format("{0}?{1}={2}", opeartion.Url, _subscriptionKeyName, _subscriptionKey);
var request = WebRequest.Create(requestUrl);
return(await this.GetAsync <HandwritingRecognitionOperationResult>("Get", request).ConfigureAwait(false));
}
public async Task <ActionResult> Index(HttpPostedFileBase file)
{
if (Request.HttpMethod == "GET")
{
return(View());
}
var model = new HandwritingModel();
HandwritingRecognitionOperation op = null;
await RunOperationOnImage(async stream =>
{
op = await VisionServiceClient.CreateHandwritingRecognitionOperationAsync(stream);
});
while (true)
{
await Task.Delay(5000);
var result = await VisionServiceClient.GetHandwritingRecognitionOperationResultAsync(op);
if (result.Status == HandwritingRecognitionOperationStatus.NotStarted ||
result.Status == HandwritingRecognitionOperationStatus.Running)
{
continue;
}
model.Result = result.RecognitionResult;
break;
}
model.ImageDump = GetInlineImageWithLines(model.Result);
if (file != null && file.ContentLength > 0)
{
if (!file.ContentType.StartsWith("image"))
{
TempData["Message"] = "Only image files may be uploaded";
}
else
{
try
{
CloudStorageAccount account = CloudStorageAccount.Parse(ConfigurationManager.AppSettings["StorageConnectionString"]);
CloudBlobClient client = account.CreateCloudBlobClient();
CloudBlobContainer container = client.GetContainerReference("pictures");
CloudBlockBlob photo = container.GetBlockBlobReference(Path.GetFileName(file.FileName));
await photo.UploadFromStreamAsync(file.InputStream);
using (var outputStream = new MemoryStream())
{
file.InputStream.Seek(0L, SeekOrigin.Begin);
var settings = new ResizeSettings {
MaxWidth = 192
};
ImageBuilder.Current.Build(file.InputStream, outputStream, settings);
outputStream.Seek(0L, SeekOrigin.Begin);
container = client.GetContainerReference("pictures");
CloudBlockBlob thumbnail = container.GetBlockBlobReference(Path.GetFileName(file.FileName));
await thumbnail.UploadFromStreamAsync(outputStream);
}
}
catch (Exception ex)
{
// In case something goes wrong
TempData["Message"] = ex.Message;
}
}
}
return(View(model));
}
