/// <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="input">Byte array 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 Task ProcessImage(byte[] input, 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(input, request);
XDocument response = performRequest(request);
Task 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);
}
}
/// <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 Task ProcessImage(string filePath, ProcessingSettings settings)
{
using (var ms = new MemoryStream())
{
var bytes = File.ReadAllBytes(filePath);
ms.Write(bytes, 0, bytes.Length);
return(ProcessImage(ms, settings));
}
}
private void PhoneApplicationPage_Loaded(object sender, RoutedEventArgs e)
{
Stream imageStream = AppData.Instance.Image;
if (imageStream == null)
return;
string localPath = "image.jpg";
saveImageToFile(imageStream, localPath);
ProcessingSettings settings = new ProcessingSettings();
settings.SetLanguage("English,Russian");
settings.OutputFormat = OutputFormat.txt;
displayMessage("Uploading..");
abbyyClient.ProcessImageAsync(localPath, settings, settings);
}
/// <summary>
/// Process directory or file with given path
/// </summary>
/// <param name="sourcePath"></param>
/// <param name="outputFilePath">Path to directory to store results
/// Will be created if it doesn't exist
/// </param>
/// <param name="processAsDocument">If true, all images are processed as a single document</param>
public void ProcessPath(string sourcePath, string outputPath, ProcessingSettings settings,
bool processAsDocument)
{
List<string> sourceFiles = new List<string>();
if (Directory.Exists(sourcePath))
{
sourceFiles.AddRange(Directory.GetFiles(sourcePath));
sourceFiles.Sort();
}
else if (File.Exists(sourcePath))
{
sourceFiles.Add(sourcePath);
}
else
{
Console.WriteLine("Invalid source path");
return;
}
if (!Directory.Exists(outputPath))
{
Directory.CreateDirectory(outputPath);
}
if (!processAsDocument || sourceFiles.Count == 1)
{
foreach (string filePath in sourceFiles)
{
string outputFileName = Path.GetFileNameWithoutExtension(filePath);
string ext = settings.OutputFileExt;
string outputFilePath = Path.Combine(outputPath, outputFileName + ext);
Console.WriteLine("Processing " + Path.GetFileName(filePath));
ProcessFile(filePath, outputFilePath, settings);
}
}
else
{
string outputFileName = "document";
string ext = settings.OutputFileExt;
string outputFilePath = Path.Combine(outputPath, outputFileName + ext);
ProcessDocument(sourceFiles, outputFilePath, settings);
}
}
public Task 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);
Task serverTask = ServerXml.GetTaskStatus(response);
return(serverTask);
}
/// <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>
/// 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) =>
{
Task 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();
}
private static ProcessingSettings buildSettings(string language, string outputFormat)
{
ProcessingSettings settings = new ProcessingSettings();
settings.SetLanguage( language );
switch (outputFormat.ToLower())
{
case "txt": settings.OutputFormat = OutputFormat.txt; break;
case "rtf": settings.OutputFormat = OutputFormat.rtf; break;
case "docx": settings.OutputFormat = OutputFormat.docx; break;
case "xlsx": settings.OutputFormat = OutputFormat.xlsx; break;
case "pptx": settings.OutputFormat = OutputFormat.pptx; break;
case "pdfsearchable": settings.OutputFormat = OutputFormat.pdfSearchable; break;
case "pdftextandimages": settings.OutputFormat = OutputFormat.pdfTextAndImages; break;
case "xml": settings.OutputFormat = OutputFormat.xml; break;
default:
throw new ArgumentException("Invalid output format");
}
return settings;
}
public void ProcessFile(string sourceFilePath, string outputFileBase, ProcessingSettings settings)
{
Console.WriteLine("Uploading..");
Task task = restClient.ProcessImage(sourceFilePath, settings);
TaskId taskId = task.Id;
while (true)
{
task = restClient.GetTaskStatus(taskId);
if (!Task.IsTaskActive(task.Status))
break;
Console.WriteLine(String.Format("Task status: {0}", task.Status));
System.Threading.Thread.Sleep(1000);
}
if (task.Status == TaskStatus.Completed)
{
Console.WriteLine("Processing completed.");
for (int i = 0; i < settings.OutputFormats.Count; i++)
{
var outputFormat = settings.OutputFormats[i];
string ext = settings.GetOutputFileExt(outputFormat);
restClient.DownloadUrl(task.DownloadUrls[i], outputFileBase + ext);
}
Console.WriteLine("Download completed.");
}
else if (task.Status == TaskStatus.NotEnoughCredits)
{
Console.WriteLine("Not enough credits to process the file. Please add more pages to your application balance.");
}
else
{
Console.WriteLine("Error while processing the task");
}
}
ProcessingSettings GetProcessingSettings()
{
ProcessingSettings result = new ProcessingSettings();
result.Language = getLanguage();
result.OutputFormat = getOutputFormat();
return result;
}
/// <summary>
/// Upload a file to service synchronously and start processing
/// </summary>
/// <param name="inputStream">Stream 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 Task ProcessImage(Stream inputStream, ProcessingSettings settings)
{
return(ProcessImage(toByteArray(inputStream), settings));
}
ProcessingSettings GetProcessingSettings()
{
ProcessingSettings result = new ProcessingSettings();
result.SetLanguage(getLanguages());
result.SetOutputFormat( getOutputFormat() );
return result;
}
public void ProcessDocument(IEnumerable<string> _sourceFiles, string outputFileBase,
ProcessingSettings settings)
{
string[] sourceFiles = _sourceFiles.ToArray();
Console.WriteLine(String.Format("Recognizing {0} images as a document",
sourceFiles.Length));
Task task = null;
for (int fileIndex = 0; fileIndex < sourceFiles.Length; fileIndex++)
{
string filePath = sourceFiles[fileIndex];
Console.WriteLine("{0}: uploading {1}", fileIndex + 1, Path.GetFileName(filePath));
task = restClient.UploadAndAddFileToTask(filePath, task == null ? null : task.Id);
}
// Start task
Console.WriteLine("Starting task..");
task = restClient.StartProcessingTask(task.Id, settings);
task = waitForTask(task);
if (task.Status == TaskStatus.Completed)
{
Console.WriteLine("Processing completed.");
for( int i = 0; i < settings.OutputFormats.Count; i++ )
{
var outputFormat = settings.OutputFormats[i];
string ext = settings.GetOutputFileExt(outputFormat);
restClient.DownloadUrl(task.DownloadUrls[i], outputFileBase + ext);
}
Console.WriteLine("Download completed.");
}
else
{
Console.WriteLine("Error while processing the task");
}
}
public void ProcessFile(string sourceFilePath, string outputFileBase, ProcessingSettings settings)
{
Console.WriteLine("Uploading..");
Task task = restClient.ProcessImage(sourceFilePath, settings);
task = waitForTask(task);
if (task.Status == TaskStatus.Completed)
{
Console.WriteLine("Processing completed.");
for (int i = 0; i < settings.OutputFormats.Count; i++)
{
var outputFormat = settings.OutputFormats[i];
string ext = settings.GetOutputFileExt(outputFormat);
restClient.DownloadUrl(task.DownloadUrls[i], outputFileBase + ext);
}
Console.WriteLine("Download completed.");
}
else if (task.Status == TaskStatus.NotEnoughCredits)
{
Console.WriteLine("Not enough credits to process the file. Please add more pages to your application balance.");
}
else
{
Console.WriteLine("Error while processing the task");
}
}
public void ProcessDocument(IEnumerable<string> _sourceFiles, string outputFilePath,
ProcessingSettings settings)
{
string[] sourceFiles = _sourceFiles.ToArray();
Console.WriteLine(String.Format("Recognizing {0} images as a document",
sourceFiles.Length));
Task task = null;
for (int fileIndex = 0; fileIndex < sourceFiles.Length; fileIndex++)
{
string filePath = sourceFiles[fileIndex];
Console.WriteLine("{0}: uploading {1}", fileIndex + 1, Path.GetFileName(filePath));
task = restClient.UploadAndAddFileToTask(filePath, task == null ? null : task.Id);
}
// Start task
Console.WriteLine("Starting task..");
restClient.StartProcessingTask(task.Id, settings);
while (true)
{
task = restClient.GetTaskStatus(task.Id);
if (!Task.IsTaskActive(task.Status))
break;
Console.WriteLine(String.Format("Task status: {0}", task.Status));
System.Threading.Thread.Sleep(1000);
}
if (task.Status == TaskStatus.Completed)
{
Console.WriteLine("Processing completed.");
restClient.DownloadResult(task, outputFilePath);
Console.WriteLine("Download completed.");
}
else
{
Console.WriteLine("Error while processing the task");
}
}
public void ProcessFile(string sourceFilePath, string outputFilePath, ProcessingSettings settings)
{
Console.WriteLine("Uploading..");
Task task = restClient.ProcessImage(sourceFilePath, settings);
// For field-level
/*
var flSettings = new TextFieldProcessingSettings();
TaskId taskId = restClient.ProcessTextField(sourceFilePath, flSettings);
*/
TaskId taskId = task.Id;
while (true)
{
task = restClient.GetTaskStatus(taskId);
if (!Task.IsTaskActive(task.Status))
break;
Console.WriteLine(String.Format("Task status: {0}", task.Status));
System.Threading.Thread.Sleep(1000);
}
if (task.Status == TaskStatus.Completed)
{
Console.WriteLine("Processing completed.");
restClient.DownloadResult(task, outputFilePath);
Console.WriteLine("Download completed.");
}
else if (task.Status == TaskStatus.NotEnoughCredits)
{
Console.WriteLine("Not enough credits to process the file. Please add more pages to your application balance.");
}
else
{
Console.WriteLine("Error while processing the task");
}
}
public void ProcessImageAsync(string filePath, ProcessingSettings settings, object taskId)
{
processFileAsync(filePath, settings, taskId);
}
public void UploadFileAsync(string filePath, ProcessingSettings settings, object taskId)
{
processFileAsync(filePath, settings, taskId);
}
private static ProcessingSettings buildSettings(string language,
string outputFormat, string profile)
{
ProcessingSettings settings = new ProcessingSettings();
settings.SetLanguage( language );
switch (outputFormat.ToLower())
{
case "txt": settings.SetOutputFormat(OutputFormat.txt); break;
case "rtf": settings.SetOutputFormat( OutputFormat.rtf); break;
case "docx": settings.SetOutputFormat( OutputFormat.docx); break;
case "xlsx": settings.SetOutputFormat( OutputFormat.xlsx); break;
case "pptx": settings.SetOutputFormat( OutputFormat.pptx); break;
case "pdfsearchable": settings.SetOutputFormat( OutputFormat.pdfSearchable); break;
case "pdftextandimages": settings.SetOutputFormat( OutputFormat.pdfTextAndImages); break;
case "xml": settings.SetOutputFormat( OutputFormat.xml); break;
default:
throw new ArgumentException("Invalid output format");
}
if (profile != null)
{
switch (profile.ToLower())
{
case "documentconversion":
settings.Profile = Profile.documentConversion;
break;
case "documentarchiving":
settings.Profile = Profile.documentArchiving;
break;
case "textextraction":
settings.Profile = Profile.textExtraction;
break;
default:
throw new ArgumentException("Invalid profile");
}
}
return settings;
}