public void AddTask(OcrSdkTask task) { lock (allTasks) { allTasks.Add(task.Id, task); } }
/// <summary> /// Download task that has finished processing and save it to given path /// </summary> /// <param name="task">Id of a task</param> /// <param name="outputFile">Path to save a file</param> public void DownloadResult(OcrSdkTask task, string outputFile) { if (task.Status != TaskStatus.Completed) { throw new ArgumentException("Cannot download result for not completed task"); } try { if (File.Exists(outputFile)) { File.Delete(outputFile); } if (task.DownloadUrls == null || task.DownloadUrls.Count == 0) { throw new ArgumentException("Cannot download task without download url"); } string url = task.DownloadUrls[0]; DownloadUrl(url, outputFile); } catch (System.Net.WebException e) { throw new ProcessingErrorException(e.Message, e); } }
// This is the method that the underlying, free-threaded // asynchronous behavior will invoke. This will happen on // a worker thread private void processCompletionMethod( OcrSdkTask task, Exception exception, bool canceled, AsyncOperation asyncOp) { // If the task was not previously canceled, // remove the task from the lifetime collection. if (!canceled) { lock (processJobs) { processJobs.Remove(asyncOp.UserSuppliedState); } } // Package the results of the operation in EventArgs TaskEventArgs e = new TaskEventArgs(task, exception, canceled, asyncOp.UserSuppliedState); // End the task. The asyncOp object is responsible // for marshaling the call. asyncOp.PostOperationCompleted(onProcessingCompleteDelegate, e); // Note that after the call to OperationCompleted, // asyncOp is no longer usable, and any attempt to use it // will cause an exception to be thrown. }
/// <summary> /// Upload a file to service synchronously and start processing /// </summary> /// <param name="filePath">Path to an image to process</param> /// <param name="settings">Language and output format</param> /// <returns>Id of the task. Check task status to see if you have enough units to process the task</returns> /// <exception cref="ProcessingErrorException">thrown when something goes wrong</exception> public OcrSdkTask ProcessImage(string filePath, ProcessingSettings settings) { string url = String.Format("{0}/processImage?{1}", ServerUrl, settings.AsUrlParams); if (!String.IsNullOrEmpty(settings.Description)) { url = url + "&description=" + Uri.EscapeDataString(settings.Description); } try { // Build post request WebRequest request = WebRequest.Create(url); setupPostRequest(url, request); writeFileToRequest(filePath, request); XDocument response = performRequest(request); OcrSdkTask task = ServerXml.GetTaskStatus(response); return(task); } catch (System.Net.WebException e) { throw new ProcessingErrorException("Cannot upload file: " + e.Message + ". Please make sure that application Id and password are correct.", e); } }
/// <summary> /// Upload a file to service synchronously and start processing /// </summary> /// <param name="filePath">Path to an image to process</param> /// <param name="settings">Language and output format</param> /// <returns>Id of the task. Check task status to see if you have enough units to process the task</returns> /// <exception cref="ProcessingErrorException">thrown when something goes wrong</exception> public OcrSdkTask ProcessImage(string filePath, ProcessingSettings settings) { string url = String.Format("{0}/processImage?{1}", ServerUrl, settings.AsUrlParams); if (!String.IsNullOrEmpty(settings.Description)) { url = url + "&description=" + Uri.EscapeDataString(settings.Description); } try { // Build post request WebRequest request = createPostRequest(url); writeFileToRequest(filePath, request); XDocument response = performRequest(request); OcrSdkTask task = ServerXml.GetTaskStatus(response); return(task); } catch (System.Net.WebException e) { String friendlyMessage = retrieveFriendlyMessage(e); if (friendlyMessage != null) { throw new ProcessingErrorException(friendlyMessage, e); } throw new ProcessingErrorException("Cannot upload file", e); } }
private void processFieldWorker(string filePath, IProcessingSettings settings, AsyncOperation asyncOp) { Exception e = null; OcrSdkTask task = new OcrSdkTask(); try { if (settings is TextFieldProcessingSettings) { task = _syncClient.ProcessTextField(filePath, settings as TextFieldProcessingSettings); } else if (settings is BarcodeFieldProcessingSettings) { task = _syncClient.ProcessBarcodeField(filePath, settings as BarcodeFieldProcessingSettings); } else if (settings is CheckmarkFieldProcessingSettings) { task = _syncClient.ProcessCheckmarkField(filePath, settings as CheckmarkFieldProcessingSettings); } else { throw new ArgumentException("Invalid type of processing settings"); } // Notify that upload was completed OcrSdkTask uploadedTask = new OcrSdkTask(task.Id, TaskStatus.Submitted); UploadCompletedEventArgs uploadCompletedEventArgs = new UploadCompletedEventArgs(uploadedTask, asyncOp.UserSuppliedState); asyncOp.Post(onUploadCompletedDelegate, uploadCompletedEventArgs); // Wait until task finishes startTaskMonitorIfNecessary(); _taskList.AddTask(task); task = waitUntilTaskFinishes(task); } catch (Exception ex) { e = ex; } lock (processJobs) { processJobs.Remove(asyncOp.UserSuppliedState); } bool canceled = false; // Package the results of the operation in EventArgs TaskEventArgs ev = new TaskEventArgs(task, e, canceled, asyncOp.UserSuppliedState); // End the task. The asyncOp object is responsible // for marshaling the call. asyncOp.PostOperationCompleted(onProcessingCompleteDelegate, ev); }
public OcrSdkTask GetTaskStatus(TaskId task) { string url = String.Format("{0}/getTaskStatus?taskId={1}", ServerUrl, Uri.EscapeDataString(task.ToString())); WebRequest request = createGetRequest(url); XDocument response = performRequest(request); OcrSdkTask serverTask = ServerXml.GetTaskStatus(response); return(serverTask); }
/// <summary> /// Recognize Machine-Readable Zone of an official document (Passport, ID, Visa etc) /// </summary> public OcrSdkTask ProcessMrz(string filePath) { string url = String.Format("{0}/processMRZ", ServerUrl); WebRequest request = createPostRequest(url); writeFileToRequest(filePath, request); XDocument response = performRequest(request); OcrSdkTask serverTask = ServerXml.GetTaskStatus(response); return(serverTask); }
public static OcrSdkTask[] GetAllTasks(XDocument xml) { List <OcrSdkTask> result = new List <OcrSdkTask>(); XElement xResponse = xml.Root; foreach (XElement xTask in xResponse.Elements("task")) { OcrSdkTask task = getTaskInfo(xTask); result.Add(task); } return(result.ToArray()); }
public OcrSdkTask ProcessBusinessCard(string filePath, BusCardProcessingSettings settings) { string url = String.Format("{0}/processBusinessCard?{1}", ServerUrl, settings.AsUrlParams); // Build post request WebRequest request = createPostRequest(url); writeFileToRequest(filePath, request); XDocument response = performRequest(request); OcrSdkTask serverTask = ServerXml.GetTaskStatus(response); return(serverTask); }
private void downloadFileWorker(OcrSdkTask task, string outputFilePath, AsyncOperation asyncOp) { Exception e = null; try { _syncClient.DownloadResult(task, outputFilePath); } catch (Exception ex) { e = ex; } downloadCompletionMethod(task, e, false, asyncOp); }
public bool IsTaskFinished(TaskId taskId) { TaskStatus status = TaskStatus.Unknown; lock (allTasks) { status = allTasks[taskId].Status; } if (status == TaskStatus.Unknown || OcrSdkTask.IsTaskActive(status)) { return(false); } else { return(true); } }
/// <summary> /// Perform fields recognition of uploaded document. /// </summary> /// <param name="task">Task created by UploadAndAddFileToTask method</param> /// <param name="settingsPath">Path to file with xml processing settings.</param> public OcrSdkTask ProcessFields(OcrSdkTask task, string settingsPath) { if (!File.Exists(settingsPath)) { throw new FileNotFoundException("Settings file doesn't exist.", settingsPath); } string url = String.Format("{0}/processFields?taskId={1}", ServerUrl, task.Id); WebRequest request = createPostRequest(url); writeFileToRequest(settingsPath, request); XDocument response = performRequest(request); OcrSdkTask result = ServerXml.GetTaskStatus(response); return(result); }
private void downloadCompletionMethod( OcrSdkTask task, Exception exception, bool canceled, AsyncOperation asyncOp) { if (!canceled) { lock (downloadJobs) { downloadJobs.Remove(asyncOp.UserSuppliedState); } } TaskEventArgs e = new TaskEventArgs(task, exception, canceled, asyncOp.UserSuppliedState); asyncOp.PostOperationCompleted(onDownloadCompletedDelegate, e); }
public OcrSdkTask StartProcessingTask(TaskId taskId, ProcessingSettings settings) { string url = String.Format("{0}/processDocument?taskId={1}&{2}", ServerUrl, Uri.EscapeDataString(taskId.ToString()), settings.AsUrlParams); if (!String.IsNullOrEmpty(settings.Description)) { url = url + "&description=" + Uri.EscapeDataString(settings.Description); } // Build get request WebRequest request = createGetRequest(url); XDocument response = performRequest(request); OcrSdkTask serverTask = ServerXml.GetTaskStatus(response); return(serverTask); }
/// <summary> /// Delete task on a server. This function cannot delete tasks that are being processed. /// </summary> public OcrSdkTask DeleteTask(OcrSdkTask task) { switch (task.Status) { case TaskStatus.Deleted: case TaskStatus.InProgress: case TaskStatus.Unknown: throw new ArgumentException("Invalid task status: " + task.Status + ". Cannot delete"); } string url = String.Format("{0}/deleteTask?taskId={1}", ServerUrl, Uri.EscapeDataString(task.Id.ToString())); WebRequest request = createGetRequest(url); XDocument response = performRequest(request); OcrSdkTask serverTask = ServerXml.GetTaskStatus(response); return(serverTask); }
// This method performs the actual file processing. // It is executed on the worker thread. private void processFileWorker(string filePath, IProcessingSettings settings, AsyncOperation asyncOp) { Exception e = null; // Check that the task is still active. // The operation may have been canceled before // the thread was scheduled. OcrSdkTask task = null; try { if (settings is ProcessingSettings) { task = _syncClient.ProcessImage(filePath, settings as ProcessingSettings); } else if (settings is BusCardProcessingSettings) { task = _syncClient.ProcessBusinessCard(filePath, settings as BusCardProcessingSettings); } else if (settings is ProcessMrzSettings) { task = _syncClient.ProcessMrz(filePath); } // Notify subscriber that upload completed OcrSdkTask uploadedTask = new OcrSdkTask(task.Id, TaskStatus.Submitted); UploadCompletedEventArgs uploadCompletedEventArgs = new UploadCompletedEventArgs(uploadedTask, asyncOp.UserSuppliedState); asyncOp.Post(onUploadCompletedDelegate, uploadCompletedEventArgs); startTaskMonitorIfNecessary(); _taskList.AddTask(task); task = waitUntilTaskFinishes(task); // task is modified on server } catch (Exception ex) { e = ex; } processCompletionMethod(task, e, false, asyncOp); }
public void DownloadResult(OcrSdkTask task, string outputFile) { if (task.Status != TaskStatus.Completed) { throw new ArgumentException("Cannot download result for not completed task"); } try { if (task.DownloadUrl == null) { throw new ArgumentException("Cannot download task without download url"); } using (IsolatedStorageFile storage = IsolatedStorageFile.GetUserStoreForApplication()) { if (storage.FileExists(outputFile)) { storage.DeleteFile(outputFile); } string url = task.DownloadUrl; WebRequest request = WebRequest.Create(url); setupGetRequest(url, request); using (HttpWebResponse result = (HttpWebResponse)request.GetResponse()) { using (Stream stream = result.GetResponseStream()) { // Write result directly to file using (Stream file = storage.OpenFile(outputFile, FileMode.Create)) { copyStream(stream, file); } } } } } catch (System.Net.WebException e) { throw new ProcessingErrorException(e.Message, e); } }
/// <summary> /// Download file asynchronously /// Performs DownloadFileCompleted callback /// </summary> public void DownloadFileAsync(OcrSdkTask task, string outputPath, object userTaskId) { AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(userTaskId); lock (downloadJobs) { if (downloadJobs.ContainsKey(userTaskId)) { throw new ArgumentException("Task ID parameter must be unique", "userTaskId"); } downloadJobs[userTaskId] = asyncOp; } // Start the asynchronous operation. downloadWorkerEventHandler workerDelegate = new downloadWorkerEventHandler(downloadFileWorker); workerDelegate.BeginInvoke(task, outputPath, asyncOp, null, null); }
/// <summary> /// Upload a file to service synchronously and start processing /// </summary> /// <param name="filePath">Path to an image to process</param> /// <param name="settings">Language and output format</param> /// <returns>Id of the task. Check task status to see if you have enough units to process the task</returns> /// <exception cref="ProcessingErrorException">thrown when something goes wrong</exception> public OcrSdkTask ProcessImage(string filePath, ProcessingSettings settings) { string url = String.Format("{0}/processImage?{1}", ServerUrl, settings.AsUrlParams); if (!String.IsNullOrEmpty(settings.Description)) { url = url + "&description=" + Uri.EscapeDataString(settings.Description); } // Build post request WebRequest request = createPostRequest(url); writeFileToRequest(filePath, request); XDocument response = performRequest(request); OcrSdkTask task = ServerXml.GetTaskStatus(response); return(task); }
/// <summary> /// Submit and process image asynchronously. /// Performs callbacks: /// UploadFileCompleted /// TaskProcessingCompleted /// </summary> /// <param name="filePath">Path to file in isolated storage</param> /// <param name="settings"></param> /// <param name="userState"></param> public void ProcessImageAsync(string filePath, ProcessingSettings settings, object userState) { BackgroundWorker w = new BackgroundWorker(); w.DoWork += new DoWorkEventHandler((sender, e) => { OcrSdkTask task = null; try { task = _syncClient.ProcessImage(filePath, settings); UploadCompletedEventArgs uploadArgs = new UploadCompletedEventArgs(task, userState); onUploadFileCompleted(sender, uploadArgs); // Wait until task finishes while (true) { task = _syncClient.GetTaskStatus(task.Id); if (!task.IsTaskActive()) { break; } Thread.Sleep(1000); } if (task.Status == TaskStatus.NotEnoughCredits) { throw new Exception("Not enough credits to process image. Please add more pages to your application's account."); } TaskEventArgs taskArgs = new TaskEventArgs(task, null, false, userState); onProcessingCompleted(sender, taskArgs); } catch (Exception ex) { TaskEventArgs taskArgs = new TaskEventArgs(task, ex, false, userState); onProcessingCompleted(sender, taskArgs); } } ); w.RunWorkerAsync(); }
/// <summary> /// Upload image of a multipage document to server. /// </summary> /// <param name="filePath">Path to an image to process</param> /// <param name="taskToAddFile">Id of multipage document. If null, a new document is created</param> /// <returns>Id of document to which image was added</returns> public OcrSdkTask UploadAndAddFileToTask(string filePath, TaskId taskToAddFile) { string url = String.Format("{0}/submitImage", ServerUrl); if (taskToAddFile != null) { url = url + "?taskId=" + Uri.EscapeDataString(taskToAddFile.ToString()); } // Build post request WebRequest request = createPostRequest(url); writeFileToRequest(filePath, request); XDocument response = performRequest(request); OcrSdkTask task = ServerXml.GetTaskStatus(response); return(task); }
/// <summary> /// Download file asynchronously /// Performs DownloadFileCompleted callback /// </summary> public void DownloadFileAsync(OcrSdkTask task, string outputPath, object userState) { BackgroundWorker w = new BackgroundWorker(); w.DoWork += new DoWorkEventHandler((sender, e) => { try { _syncClient.DownloadResult(task, outputPath); TaskEventArgs taskArgs = new TaskEventArgs(task, null, false, userState); onDownloadFileCompleted(sender, taskArgs); } catch (Exception ex) { TaskEventArgs taskArgs = new TaskEventArgs(task, ex, false, userState); onDownloadFileCompleted(sender, taskArgs); } } ); w.RunWorkerAsync(); }
/// <summary> /// Enter infinite loop and wait for task to complete /// </summary> /// <returns>Details about completed task</returns> private OcrSdkTask waitUntilTaskFinishes(OcrSdkTask task) { while (true) { if (_taskList.Error != null) { _taskList.DeleteTask(task.Id); throw new Exception(_taskList.Error.Message, _taskList.Error); } TaskStatus taskStatus = _taskList.GetTaskStatus(task.Id); if (_taskList.IsTaskFinished(task.Id)) { OcrSdkTask result = _taskList.GetTask(task.Id); _taskList.DeleteTask(task.Id); return(result); } Thread.Sleep(1000); } }
public UploadCompletedEventArgs(OcrSdkTask task, object userState) : base(50, userState) { _task = task; }
/// <summary> /// Get task data from xml node "task" /// </summary> private static OcrSdkTask getTaskInfo(XElement xTask) { TaskId id = new TaskId(xTask.Attribute("id").Value); TaskStatus status = statusFromString(xTask.Attribute("status").Value); OcrSdkTask task = new OcrSdkTask(); task.Id = id; task.Status = status; XAttribute xRegistrationTime = xTask.Attribute("registrationTime"); if (xRegistrationTime != null) { DateTime time; if (DateTime.TryParse(xRegistrationTime.Value, out time)) { task.RegistrationTime = time; } } XAttribute xStatusChangeTime = xTask.Attribute("statusChangeTime"); if (xStatusChangeTime != null) { DateTime time; if (DateTime.TryParse(xStatusChangeTime.Value, out time)) { task.StatusChangeTime = time; } } XAttribute xFilesCount = xTask.Attribute("filesCount"); if (xFilesCount != null) { int filesCount; if (Int32.TryParse(xFilesCount.Value, out filesCount)) { task.FilesCount = filesCount; } } XAttribute xCredits = xTask.Attribute("credits"); if (xCredits != null) { int credits; if (Int32.TryParse(xCredits.Value, out credits)) { task.Credits = credits; } } XAttribute xDescription = xTask.Attribute("description"); if (xDescription != null) { task.Description = xDescription.Value; } XAttribute xResultUrl = xTask.Attribute("resultUrl"); if (xResultUrl != null) { task.DownloadUrls = new List <string> { xResultUrl.Value }; for (int i = 2; i < 10; i++) { XAttribute xResultUrlI = xTask.Attribute("resultUrl" + i); if (xResultUrlI != null) { task.DownloadUrls.Add(xResultUrlI.Value); } else { break; } } } XAttribute xError = xTask.Attribute("error"); if (xError != null) { task.Error = xError.Value; } return(task); }
public TaskEventArgs(OcrSdkTask task, Exception e, bool canceled, object state) : base(e, canceled, state) { _task = task; }
/// <summary> /// Get task data from xml node "task" /// </summary> private static OcrSdkTask getTaskInfo(XElement xTask) { TaskId id = new TaskId(xTask.Attribute("id").Value); TaskStatus status = statusFromString(xTask.Attribute("status").Value); OcrSdkTask task = new OcrSdkTask(); task.Id = id; task.Status = status; XAttribute xRegistrationTime = xTask.Attribute("registrationTime"); if (xRegistrationTime != null) { DateTime time; if (DateTime.TryParse(xRegistrationTime.Value, out time)) { task.RegistrationTime = time; } } XAttribute xStatusChangeTime = xTask.Attribute("statusChangeTime"); if (xStatusChangeTime != null) { DateTime time; if (DateTime.TryParse(xStatusChangeTime.Value, out time)) { task.StatusChangeTime = time; } } XAttribute xPagesCount = xTask.Attribute("filesCount"); if (xPagesCount != null) { int pagesCount; if (Int32.TryParse(xPagesCount.Value, out pagesCount)) { task.PagesCount = pagesCount; } } XAttribute xCredits = xTask.Attribute("credits"); if (xCredits != null) { int credits; if (Int32.TryParse(xCredits.Value, out credits)) { task.Credits = credits; } } XAttribute xDescription = xTask.Attribute("description"); if (xDescription != null) { task.Description = xDescription.Value; } XAttribute xResultUrl = xTask.Attribute("resultUrl"); if (xResultUrl != null) { task.DownloadUrl = xResultUrl.Value; } return(task); }