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;
}
/// <summary>
/// Log text from the given HandwritingRecognitionOperationResult object.
/// </summary>
/// <param name="results">The HandwritingRecognitionOperationResult.</param>
protected void LogHandwritingRecognitionResult(HandwritingRecognitionOperationResult results)
{
StringBuilder stringBuilder = new StringBuilder();
if (results != null && results.RecognitionResult != null && results.RecognitionResult.Lines != null && results.RecognitionResult.Lines.Length > 0)
{
stringBuilder.Append("Text: ");
stringBuilder.AppendLine();
foreach (var line in results.RecognitionResult.Lines)
{
foreach (var word in line.Words)
{
stringBuilder.Append(word.Text);
stringBuilder.Append(" ");
}
stringBuilder.AppendLine();
stringBuilder.AppendLine();
}
}
if (string.IsNullOrWhiteSpace(stringBuilder.ToString()))
{
Log("No text is recognized.");
}
else
{
Log(stringBuilder.ToString());
}
if (results.Status == HandwritingRecognitionOperationStatus.Running || results.Status == HandwritingRecognitionOperationStatus.NotStarted)
{
Log(string.Format("Status is {0} after try {1} times", results.Status, MaxRetryTimes));
}
}
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 <IHttpActionResult> RecognizeHandWrittenTextByURL(string imageUrl)
{
try
{
HandwritingRecognitionOperationResult handwritingRecognitionOperationResult = await RecognizeAsync(async() => await visionServiceClient.CreateHandwritingRecognitionOperationAsync(imageUrl));
return(Ok(handwritingRecognitionOperationResult));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
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 Run([BlobTrigger("handwritten/{name}", Connection = "storage")] string content, string name, TraceWriter log)
{
var client = new Microsoft.ProjectOxford.Vision.VisionServiceClient(
Environment.GetEnvironmentVariable("Computer-Vision-Ocp-Apim-Subscription-Key"),
Environment.GetEnvironmentVariable("Computer-Vision-Api-Root"));
HandwritingRecognitionOperationResult result = null;
try
{
var operation = await client.CreateHandwritingRecognitionOperationAsync($"https://sqlsat707.blob.core.windows.net/handwritten/{name}");
result = await client.GetHandwritingRecognitionOperationResultAsync(operation);
}
catch (Exception ex)
{
throw ex;
}
// now insert
var connectionString = Environment.GetEnvironmentVariable("ConnectionString");
using (var conn = new SqlConnection(connectionString))
{
conn.Open();
var cmd = conn.CreateCommand();
cmd.CommandText = "ImportTemperatureEvent";
cmd.CommandType = CommandType.StoredProcedure;
var deviceId = cmd.Parameters.Add("@DeviceId", SqlDbType.NVarChar, 32);
var timestamp = cmd.Parameters.Add("@Timestamp", SqlDbType.DateTimeOffset);
var temperature = cmd.Parameters.Add("@Temperature", SqlDbType.Float);
foreach (var line in result.RecognitionResult.Lines)
{
deviceId.Value = line.Words[0].Text;
timestamp.Value = DateTimeOffset.Now;
temperature.Value = double.Parse(line.Words[1].Text);
cmd.ExecuteNonQuery();
}
conn.Close();
}
}
public static string[] GetExtracted(HandwritingRecognitionOperationResult res, bool wrds)
{
List <string> items = new List <string>();
foreach (HandwritingTextLine l in res.RecognitionResult.Lines)
{
if (wrds)
{
items.AddRange(GetWords(l));
}
else
{
items.Add(GetLineAsString(l));
}
}
return(items.ToArray());
}
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);
}
private static string[] GetHandWrittenExtracted(HandwritingRecognitionOperationResult hdro, bool wrds)
{
List <string> lst = new List <string>();
foreach (HandwritingTextLine lineItem in hdro.RecognitionResult.Lines)
{
if (wrds)
{
lst.AddRange(GetHandWrittingWords(lineItem));
}
else
{
lst.Add(GetHandWrittingLineString(lineItem));
}
}
return(lst.ToArray());
}
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
// -----------------------------------------------------------------------
}
private async Task <HandwritingRecognitionResult> GetResultFromOperationResponse(HttpResponseMessage response)
{
// Process operation
if (response.Headers.Contains(this.HEADER_OPLOC_KEY) == false)
{
throw new InvalidOperationException("No operation-location value returned from initial request.");
}
Uri opLocationUri = new Uri(response.Headers.GetValues(this.HEADER_OPLOC_KEY).First());
HandwritingRecognitionOperationResult opResult = new HandwritingRecognitionOperationResult();
int i = 0;
while (i++ < HttpClientUtility.RETRY_COUNT)
{
// Get the operation result
opResult = await HttpClientUtility.GetAsync <HandwritingRecognitionOperationResult>(opLocationUri, this.RequestHeaders);
// Wait if operation is running or has not started
if (opResult.Status == HandwritingRecognitionOperationResult.HandwritingRecognitionOperationStatus.NotStarted ||
opResult.Status == HandwritingRecognitionOperationResult.HandwritingRecognitionOperationStatus.Running)
{
await Task.Delay(HttpClientUtility.RETRY_DELAY);
}
else
{
break;
}
}
if (opResult.Status != HandwritingRecognitionOperationResult.HandwritingRecognitionOperationStatus.Succeeded)
{
throw new Exception($"Handwriting recognition operation was not successful with status: {opResult.Status}");
}
return(opResult.Result);
}
public async Task <IHttpActionResult> RecognizeHandWrittenText()
{
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
return(BadRequest());
}
try
{
var provider = await Request.Content.ReadAsMultipartAsync(new InMemoryMultipartFormDataStreamProvider());
var files = provider.Files;
var file1 = files[0];
var fileStream = await file1.ReadAsStreamAsync();
HandwritingRecognitionOperationResult handwritingRecognitionOperationResult = await RecognizeAsync(async() => await visionServiceClient.CreateHandwritingRecognitionOperationAsync(fileStream));
return(Ok(handwritingRecognitionOperationResult));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
