public void AnalyzeDocumentOperationArgumentValidation()
{
DocumentAnalysisClient client = CreateDocumentAnalysisClient();
Assert.Throws <ArgumentNullException>(() => new AnalyzeDocumentOperation(null, client));
Assert.Throws <ArgumentException>(() => new AnalyzeDocumentOperation(string.Empty, client));
Assert.Throws <ArgumentNullException>(() => new AnalyzeDocumentOperation(AnalyzeOperationId, null));
}
public void CreateDocumentAnalysisClientTokenCredential()
{
#region Snippet:CreateDocumentAnalysisClientTokenCredential
#if SNIPPET
string endpoint = "<endpoint>";
#else
string endpoint = TestEnvironment.Endpoint;
#endif
var client = new DocumentAnalysisClient(new Uri(endpoint), new DefaultAzureCredential());
#endregion
}
/// <summary>
/// Creates a fake <see cref="DocumentAnalysisClient" /> and instruments it to make use of the Azure Core
/// Test Framework functionalities.
/// </summary>
/// <param name="options">A set of options to apply when configuring the client.</param>
/// <returns>The instrumented <see cref="DocumentAnalysisClient" />.</returns>
private DocumentAnalysisClient CreateInstrumentedClient(DocumentAnalysisClientOptions options = default)
{
var fakeEndpoint = new Uri("http://localhost");
var fakeCredential = new AzureKeyCredential("fakeKey");
options ??= new DocumentAnalysisClientOptions();
var client = new DocumentAnalysisClient(fakeEndpoint, fakeCredential, options);
return(InstrumentClient(client));
}
public void CreateDocumentAnalysisClient()
{
#region Snippet:CreateDocumentAnalysisClient
#if SNIPPET
string endpoint = "<endpoint>";
string apiKey = "<apiKey>";
#else
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
#endif
var credential = new AzureKeyCredential(apiKey);
var client = new DocumentAnalysisClient(new Uri(endpoint), credential);
#endregion
}
/// <summary>
/// Creates a <see cref="DocumentAnalysisClient" /> with the endpoint and API key provided via environment
/// variables and instruments it to make use of the Azure Core Test Framework functionalities.
/// </summary>
/// <param name="nonInstrumentedClient">The non-instrumented version of the client to be used to resume LROs.</param>
/// <param name="useTokenCredential">Whether or not to use a <see cref="TokenCredential"/> to authenticate. An <see cref="AzureKeyCredential"/> is used by default.</param>
/// <param name="apiKey">The API key to use for authentication. Defaults to <see cref="DocumentAnalysisTestEnvironment.ApiKey"/>.</param>
/// <returns>The instrumented <see cref="DocumentAnalysisClient" />.</returns>
protected DocumentAnalysisClient CreateDocumentAnalysisClient(out DocumentAnalysisClient nonInstrumentedClient, bool useTokenCredential = false, string apiKey = default)
{
var endpoint = new Uri(TestEnvironment.Endpoint);
var options = InstrumentClientOptions(new DocumentAnalysisClientOptions(_serviceVersion));
if (useTokenCredential)
{
nonInstrumentedClient = new DocumentAnalysisClient(endpoint, TestEnvironment.Credential, options);
}
else
{
var credential = new AzureKeyCredential(apiKey ?? TestEnvironment.ApiKey);
nonInstrumentedClient = new DocumentAnalysisClient(endpoint, credential, options);
}
return(InstrumentClient(nonInstrumentedClient));
}
public async Task BadRequestSnippet()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
var credential = new AzureKeyCredential(apiKey);
var client = new DocumentAnalysisClient(new Uri(endpoint), credential);
#region Snippet:DocumentAnalysisBadRequest
try
{
AnalyzeDocumentOperation operation = await client.StartAnalyzeDocumentFromUriAsync("prebuilt-receipt", new Uri("http://invalid.uri"));
await operation.WaitForCompletionAsync();
}
catch (RequestFailedException e)
{
Console.WriteLine(e.ToString());
}
#endregion
}
public override async Task <TaxContributionResponse> ReceiveTaxContributionHonor(TaxContributionInfo request, ServerCallContext context)
{
await this.InitializeWalletsAsync();
string endpoint = "https://receipt-tax-reader.cognitiveservices.azure.com";
AzureKeyCredential credential = new AzureKeyCredential(_azureFormRecognizerApiKey);
DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), credential);
var receiptBytes = new byte[request.Receipt.Length];
request.Receipt.CopyTo(receiptBytes, 0);
using var receiptStream = new MemoryStream(receiptBytes);
AnalyzeDocumentOperation operation = await client.StartAnalyzeDocumentAsync("prebuilt-receipt", receiptStream);
await operation.WaitForCompletionAsync();
AnalyzeResult result = operation.Value;
for (int i = 0; i < result.Documents.Count; i++)
{
Console.WriteLine($"Document {i}:");
AnalyzedDocument document = result.Documents[i];
if (document.Fields.TryGetValue("TotalTax", out DocumentField? totalTaxField))
{
if (totalTaxField.ValueType == DocumentFieldType.Double)
{
double totalTax = totalTaxField.AsDouble();
Console.WriteLine($"Total Tax: '{totalTax}', with confidence {totalTaxField.Confidence}");
var airDropTx = await Sdk.Transaction.CreateAsync(KeyPair.FromAccountId(request.AccountId), _airDropWallet.Server);
// create trustline
// Remember, the TRANSACTION source account is the user's account, thus any
// OPERATION without a source account explicitly set will default to the
// transaction's source account, which is the user's account. Thus, a
// trustline is being made on the user's account.
airDropTx.AddOperation(
new ChangeTrustOperation.Builder(ChangeTrustAsset.Create(_playUSA)).Build(),
null);
airDropTx.AddOperation(new PaymentOperation.Builder(
KeyPair.FromAccountId(request.AccountId),
_playUSA,
totalTax.ToString("N7"))
.SetSourceAccount(_airDropWallet.KeyPairWithSecretSeed)
.Build(),
_airDropWallet.KeyPairWithSecretSeed);
// create trustline
// Remember, the TRANSACTION source account is the user's account, thus any
// OPERATION without a source account explicitly set will default to the
// transaction's source account, which is the user's account. Thus, a
// trustline is being made on the user's account.
airDropTx.AddOperation(
new ChangeTrustOperation.Builder(ChangeTrustAsset.Create(_playMONEY)).Build(),
null);
airDropTx.AddOperation(new PaymentOperation.Builder(
KeyPair.FromAccountId(request.AccountId),
_playMONEY,
(totalTax * UsaPricedInMoney).ToString("N7"))
.SetSourceAccount(_airDropWallet.KeyPairWithSecretSeed)
.Build(),
_airDropWallet.KeyPairWithSecretSeed);
var airDropTxXdr = airDropTx.GetXdr();
var signedAirDropTxXdr = stellar_dotnet_sdk.Transaction.FromEnvelopeXdr(airDropTxXdr);
signedAirDropTxXdr.Sign(_airDropWallet.KeyPairWithSecretSeed, _airDropWallet.NetworkInfo);
return(new TaxContributionResponse()
{
Success = new Success()
{
Success_ = true, Message = "Hello World!"
},
SignedXdr = signedAirDropTxXdr.ToEnvelopeXdrBase64()
});
}
}
}
return(new TaxContributionResponse()
{
Success = new Success()
{
Success_ = false
}
});
}
public async Task AnalyzePrebuiltDocumentFromFileAsync()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
#region Snippet:FormRecognizerAnalyzePrebuiltDocumentFromFileAsync
#if SNIPPET
string filePath = "filePath";
#else
string filePath = DocumentAnalysisTestEnvironment.CreatePath("Form_1.jpg");
#endif
using var stream = new FileStream(filePath, FileMode.Open);
AnalyzeDocumentOperation operation = await client.StartAnalyzeDocumentAsync("prebuilt-document", stream);
await operation.WaitForCompletionAsync();
AnalyzeResult result = operation.Value;
Console.WriteLine("Detected key-value pairs:");
foreach (DocumentKeyValuePair kvp in result.KeyValuePairs)
{
if (kvp.Value.Content == null)
{
Console.WriteLine($" Found key with no value: '{kvp.Key.Content}'");
}
else
{
Console.WriteLine($" Found key-value pair: '{kvp.Key.Content}' and '{kvp.Value.Content}'");
}
}
Console.WriteLine("Detected entities:");
foreach (DocumentEntity entity in result.Entities)
{
if (entity.SubCategory == null)
{
Console.WriteLine($" Found entity '{entity.Content}' with category '{entity.Category}'.");
}
else
{
Console.WriteLine($" Found entity '{entity.Content}' with category '{entity.Category}' and sub-category '{entity.SubCategory}'.");
}
}
foreach (DocumentPage page in result.Pages)
{
Console.WriteLine($"Document Page {page.PageNumber} has {page.Lines.Count} line(s), {page.Words.Count} word(s),");
Console.WriteLine($"and {page.SelectionMarks.Count} selection mark(s).");
for (int i = 0; i < page.Lines.Count; i++)
{
DocumentLine line = page.Lines[i];
Console.WriteLine($" Line {i} has content: '{line.Content}'.");
Console.WriteLine($" Its bounding box is:");
Console.WriteLine($" Upper left => X: {line.BoundingBox[0].X}, Y= {line.BoundingBox[0].Y}");
Console.WriteLine($" Upper right => X: {line.BoundingBox[1].X}, Y= {line.BoundingBox[1].Y}");
Console.WriteLine($" Lower right => X: {line.BoundingBox[2].X}, Y= {line.BoundingBox[2].Y}");
Console.WriteLine($" Lower left => X: {line.BoundingBox[3].X}, Y= {line.BoundingBox[3].Y}");
}
for (int i = 0; i < page.SelectionMarks.Count; i++)
{
DocumentSelectionMark selectionMark = page.SelectionMarks[i];
Console.WriteLine($" Selection Mark {i} is {selectionMark.State}.");
Console.WriteLine($" Its bounding box is:");
Console.WriteLine($" Upper left => X: {selectionMark.BoundingBox[0].X}, Y= {selectionMark.BoundingBox[0].Y}");
Console.WriteLine($" Upper right => X: {selectionMark.BoundingBox[1].X}, Y= {selectionMark.BoundingBox[1].Y}");
Console.WriteLine($" Lower right => X: {selectionMark.BoundingBox[2].X}, Y= {selectionMark.BoundingBox[2].Y}");
Console.WriteLine($" Lower left => X: {selectionMark.BoundingBox[3].X}, Y= {selectionMark.BoundingBox[3].Y}");
}
}
foreach (DocumentStyle style in result.Styles)
{
// Check the style and style confidence to see if text is handwritten.
// Note that value '0.8' is used as an example.
bool isHandwritten = style.IsHandwritten.HasValue && style.IsHandwritten == true;
if (isHandwritten && style.Confidence > 0.8)
{
Console.WriteLine($"Handwritten content found:");
foreach (DocumentSpan span in style.Spans)
{
Console.WriteLine($" Content: {result.Content.Substring(span.Offset, span.Length)}");
}
}
}
Console.WriteLine("The following tables were extracted:");
for (int i = 0; i < result.Tables.Count; i++)
{
DocumentTable table = result.Tables[i];
Console.WriteLine($" Table {i} has {table.RowCount} rows and {table.ColumnCount} columns.");
foreach (DocumentTableCell cell in table.Cells)
{
Console.WriteLine($" Cell ({cell.RowIndex}, {cell.ColumnIndex}) has kind '{cell.Kind}' and content: '{cell.Content}'.");
}
}
#endregion
}
public async Task AnalyzeWithCustomModelFromFileAsync()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
Uri trainingFileUri = new Uri(TestEnvironment.BlobContainerSasUrl);
// Firstly, create a custom built model we can use to recognize the custom document. Please note
// that models can also be built using a graphical user interface such as the Form Recognizer
// Labeling Tool found here:
// https://aka.ms/azsdk/formrecognizer/labelingtool
var adminClient = new DocumentModelAdministrationClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
BuildModelOperation buildOperation = await adminClient.StartBuildModelAsync(trainingFileUri);
await buildOperation.WaitForCompletionAsync();
DocumentModel customModel = buildOperation.Value;
// Proceed with the custom document recognition.
DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
#region Snippet:FormRecognizerAnalyzeWithCustomModelFromFileAsync
#if SNIPPET
string modelId = "<modelId>";
string filePath = "<filePath>";
#else
string filePath = DocumentAnalysisTestEnvironment.CreatePath("Form_1.jpg");
string modelId = customModel.ModelId;
#endif
using var stream = new FileStream(filePath, FileMode.Open);
AnalyzeDocumentOperation operation = await client.StartAnalyzeDocumentAsync(modelId, stream);
await operation.WaitForCompletionAsync();
AnalyzeResult result = operation.Value;
Console.WriteLine($"Document was analyzed with model with ID: {result.ModelId}");
foreach (AnalyzedDocument document in result.Documents)
{
Console.WriteLine($"Document of type: {document.DocType}");
foreach (KeyValuePair <string, DocumentField> fieldKvp in document.Fields)
{
string fieldName = fieldKvp.Key;
DocumentField field = fieldKvp.Value;
Console.WriteLine($"Field '{fieldName}': ");
Console.WriteLine($" Content: '{field.Content}'");
Console.WriteLine($" Confidence: '{field.Confidence}'");
}
}
#endregion
// Iterate over lines and selection marks on each page
foreach (DocumentPage page in result.Pages)
{
Console.WriteLine($"Lines found on page {page.PageNumber}");
foreach (var line in page.Lines)
{
Console.WriteLine($" {line.Content}");
}
Console.WriteLine($"Selection marks found on page {page.PageNumber}");
foreach (var selectionMark in page.SelectionMarks)
{
Console.WriteLine($" Selection mark is '{selectionMark.State}' with confidence {selectionMark.Confidence}");
}
}
// Iterate over the document tables
for (int i = 0; i < result.Tables.Count; i++)
{
Console.WriteLine($"Table {i + 1}");
foreach (var cell in result.Tables[i].Cells)
{
Console.WriteLine($" Cell[{cell.RowIndex}][{cell.ColumnIndex}] has content '{cell.Content}' with kind '{cell.Kind}'");
}
}
// Delete the model on completion to clean environment.
await adminClient.DeleteModelAsync(customModel.ModelId);
}
public async Task AnalyzePrebuiltDocumentFromUriAsync()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
#region Snippet:FormRecognizerAnalyzePrebuiltDocumentFromUriAsync
#if SNIPPET
Uri fileUri = new Uri("<fileUri>");
#else
Uri fileUri = DocumentAnalysisTestEnvironment.CreateUri("Form_1.jpg");
#endif
AnalyzeDocumentOperation operation = await client.StartAnalyzeDocumentFromUriAsync("prebuilt-document", fileUri);
await operation.WaitForCompletionAsync();
AnalyzeResult result = operation.Value;
Console.WriteLine("Detected key-value pairs:");
foreach (DocumentKeyValuePair kvp in result.KeyValuePairs)
{
if (kvp.Value == null)
{
Console.WriteLine($" Found key with no value: '{kvp.Key.Content}'");
}
else
{
Console.WriteLine($" Found key-value pair: '{kvp.Key.Content}' and '{kvp.Value.Content}'");
}
}
foreach (DocumentPage page in result.Pages)
{
Console.WriteLine($"Document Page {page.PageNumber} has {page.Lines.Count} line(s), {page.Words.Count} word(s),");
Console.WriteLine($"and {page.SelectionMarks.Count} selection mark(s).");
for (int i = 0; i < page.Lines.Count; i++)
{
DocumentLine line = page.Lines[i];
Console.WriteLine($" Line {i} has content: '{line.Content}'.");
Console.WriteLine($" Its bounding polygon (points ordered clockwise):");
for (int j = 0; j < line.BoundingPolygon.Points.Length; j++)
{
Console.WriteLine($" Point {j} => X: {line.BoundingPolygon[j].X}, Y: {line.BoundingPolygon[j].Y}");
}
}
for (int i = 0; i < page.SelectionMarks.Count; i++)
{
DocumentSelectionMark selectionMark = page.SelectionMarks[i];
Console.WriteLine($" Selection Mark {i} is {selectionMark.State}.");
Console.WriteLine($" Its bounding polygon (points ordered clockwise):");
for (int j = 0; j < selectionMark.BoundingPolygon.Points.Length; j++)
{
Console.WriteLine($" Point {j} => X: {selectionMark.BoundingPolygon[j].X}, Y: {selectionMark.BoundingPolygon[j].Y}");
}
}
}
foreach (DocumentStyle style in result.Styles)
{
// Check the style and style confidence to see if text is handwritten.
// Note that value '0.8' is used as an example.
bool isHandwritten = style.IsHandwritten.HasValue && style.IsHandwritten == true;
if (isHandwritten && style.Confidence > 0.8)
{
Console.WriteLine($"Handwritten content found:");
foreach (DocumentSpan span in style.Spans)
{
Console.WriteLine($" Content: {result.Content.Substring(span.Offset, span.Length)}");
}
}
}
Console.WriteLine("The following tables were extracted:");
for (int i = 0; i < result.Tables.Count; i++)
{
DocumentTable table = result.Tables[i];
Console.WriteLine($" Table {i} has {table.RowCount} rows and {table.ColumnCount} columns.");
foreach (DocumentTableCell cell in table.Cells)
{
Console.WriteLine($" Cell ({cell.RowIndex}, {cell.ColumnIndex}) has kind '{cell.Kind}' and content: '{cell.Content}'.");
}
}
#endregion
}
public async Task AnalyzePrebuiltReadFromUriAsync()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
#region Snippet:FormRecognizerAnalyzePrebuiltReadFromUriAsync
#if SNIPPET
Uri fileUri = new Uri("<fileUri>");
#else
Uri fileUri = DocumentAnalysisTestEnvironment.CreateUri("Form_1.jpg");
#endif
AnalyzeDocumentOperation operation = await client.StartAnalyzeDocumentFromUriAsync("prebuilt-read", fileUri);
await operation.WaitForCompletionAsync();
AnalyzeResult result = operation.Value;
Console.WriteLine("Detected languages:");
foreach (DocumentLanguage language in result.Languages)
{
Console.WriteLine($" Found language '{language.LanguageCode}' with confidence {language.Confidence}.");
}
foreach (DocumentPage page in result.Pages)
{
Console.WriteLine($"Document Page {page.PageNumber} has {page.Lines.Count} line(s), {page.Words.Count} word(s),");
Console.WriteLine($"and {page.SelectionMarks.Count} selection mark(s).");
for (int i = 0; i < page.Lines.Count; i++)
{
DocumentLine line = page.Lines[i];
Console.WriteLine($" Line {i} has content: '{line.Content}'.");
Console.WriteLine($" Its bounding box is:");
Console.WriteLine($" Upper left => X: {line.BoundingBox[0].X}, Y= {line.BoundingBox[0].Y}");
Console.WriteLine($" Upper right => X: {line.BoundingBox[1].X}, Y= {line.BoundingBox[1].Y}");
Console.WriteLine($" Lower right => X: {line.BoundingBox[2].X}, Y= {line.BoundingBox[2].Y}");
Console.WriteLine($" Lower left => X: {line.BoundingBox[3].X}, Y= {line.BoundingBox[3].Y}");
}
}
foreach (DocumentStyle style in result.Styles)
{
// Check the style and style confidence to see if text is handwritten.
// Note that value '0.8' is used as an example.
bool isHandwritten = style.IsHandwritten.HasValue && style.IsHandwritten == true;
if (isHandwritten && style.Confidence > 0.8)
{
Console.WriteLine($"Handwritten content found:");
foreach (DocumentSpan span in style.Spans)
{
Console.WriteLine($" Content: {result.Content.Substring(span.Offset, span.Length)}");
}
}
}
#endregion
}
public async Task AnalyzeWithPrebuiltModelFromFileAsync()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
#region Snippet:FormRecognizerAnalyzeWithPrebuiltModelFromFileAsync
#if SNIPPET
string filePath = "<filePath>";
#else
string filePath = DocumentAnalysisTestEnvironment.CreatePath("recommended_invoice.jpg");
#endif
using var stream = new FileStream(filePath, FileMode.Open);
AnalyzeDocumentOperation operation = await client.StartAnalyzeDocumentAsync("prebuilt-invoice", stream);
await operation.WaitForCompletionAsync();
AnalyzeResult result = operation.Value;
// To see the list of all the supported fields returned by service and its corresponding types for the
// prebuilt-invoice model, consult:
// https://aka.ms/azsdk/formrecognizer/invoicefieldschema
for (int i = 0; i < result.Documents.Count; i++)
{
Console.WriteLine($"Document {i}:");
AnalyzedDocument document = result.Documents[i];
if (document.Fields.TryGetValue("VendorName", out DocumentField vendorNameField))
{
if (vendorNameField.ValueType == DocumentFieldType.String)
{
string vendorName = vendorNameField.AsString();
Console.WriteLine($"Vendor Name: '{vendorName}', with confidence {vendorNameField.Confidence}");
}
}
if (document.Fields.TryGetValue("CustomerName", out DocumentField customerNameField))
{
if (customerNameField.ValueType == DocumentFieldType.String)
{
string customerName = customerNameField.AsString();
Console.WriteLine($"Customer Name: '{customerName}', with confidence {customerNameField.Confidence}");
}
}
if (document.Fields.TryGetValue("Items", out DocumentField itemsField))
{
if (itemsField.ValueType == DocumentFieldType.List)
{
foreach (DocumentField itemField in itemsField.AsList())
{
Console.WriteLine("Item:");
if (itemField.ValueType == DocumentFieldType.Dictionary)
{
IReadOnlyDictionary <string, DocumentField> itemFields = itemField.AsDictionary();
if (itemFields.TryGetValue("Description", out DocumentField itemDescriptionField))
{
if (itemDescriptionField.ValueType == DocumentFieldType.String)
{
string itemDescription = itemDescriptionField.AsString();
Console.WriteLine($" Description: '{itemDescription}', with confidence {itemDescriptionField.Confidence}");
}
}
if (itemFields.TryGetValue("Amount", out DocumentField itemAmountField))
{
if (itemAmountField.ValueType == DocumentFieldType.Currency)
{
CurrencyValue itemAmount = itemAmountField.AsCurrency();
Console.WriteLine($" Amount: '{itemAmount.Symbol}{itemAmount.Amount}', with confidence {itemAmountField.Confidence}");
}
}
}
}
}
}
if (document.Fields.TryGetValue("SubTotal", out DocumentField subTotalField))
{
if (subTotalField.ValueType == DocumentFieldType.Currency)
{
CurrencyValue subTotal = subTotalField.AsCurrency();
Console.WriteLine($"Sub Total: '{subTotal.Symbol}{subTotal.Amount}', with confidence {subTotalField.Confidence}");
}
}
if (document.Fields.TryGetValue("TotalTax", out DocumentField totalTaxField))
{
if (totalTaxField.ValueType == DocumentFieldType.Currency)
{
CurrencyValue totalTax = totalTaxField.AsCurrency();
Console.WriteLine($"Total Tax: '{totalTax.Symbol}{totalTax.Amount}', with confidence {totalTaxField.Confidence}");
}
}
if (document.Fields.TryGetValue("InvoiceTotal", out DocumentField invoiceTotalField))
{
if (invoiceTotalField.ValueType == DocumentFieldType.Currency)
{
CurrencyValue invoiceTotal = invoiceTotalField.AsCurrency();
Console.WriteLine($"Invoice Total: '{invoiceTotal.Symbol}{invoiceTotal.Amount}', with confidence {invoiceTotalField.Confidence}");
}
}
}
#endregion
}
public async Task AnalyzePrebuiltReadFromFileAsync()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
#region Snippet:FormRecognizerAnalyzePrebuiltReadFromFileAsync
#if SNIPPET
string filePath = "<filePath>";
#else
string filePath = DocumentAnalysisTestEnvironment.CreatePath("Form_1.jpg");
#endif
using var stream = new FileStream(filePath, FileMode.Open);
AnalyzeDocumentOperation operation = await client.StartAnalyzeDocumentAsync("prebuilt-read", stream);
await operation.WaitForCompletionAsync();
AnalyzeResult result = operation.Value;
Console.WriteLine("Detected languages:");
foreach (DocumentLanguage language in result.Languages)
{
Console.WriteLine($" Found language with locale '{language.Locale}' and confidence {language.Confidence}.");
}
foreach (DocumentPage page in result.Pages)
{
Console.WriteLine($"Document Page {page.PageNumber} has {page.Lines.Count} line(s), {page.Words.Count} word(s),");
Console.WriteLine($"and {page.SelectionMarks.Count} selection mark(s).");
for (int i = 0; i < page.Lines.Count; i++)
{
DocumentLine line = page.Lines[i];
Console.WriteLine($" Line {i} has content: '{line.Content}'.");
Console.WriteLine($" Its bounding polygon (points ordered clockwise):");
for (int j = 0; j < line.BoundingPolygon.Points.Length; j++)
{
Console.WriteLine($" Point {j} => X: {line.BoundingPolygon[j].X}, Y: {line.BoundingPolygon[j].Y}");
}
}
}
foreach (DocumentStyle style in result.Styles)
{
// Check the style and style confidence to see if text is handwritten.
// Note that value '0.8' is used as an example.
bool isHandwritten = style.IsHandwritten.HasValue && style.IsHandwritten == true;
if (isHandwritten && style.Confidence > 0.8)
{
Console.WriteLine($"Handwritten content found:");
foreach (DocumentSpan span in style.Spans)
{
Console.WriteLine($" Content: {result.Content.Substring(span.Offset, span.Length)}");
}
}
}
#endregion
}
public async Task ExtractLayoutFromUriAsync()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
#region Snippet:FormRecognizerExtractLayoutFromUriAsync
#if SNIPPET
string fileUri = "<fileUri>";
#else
Uri fileUri = DocumentAnalysisTestEnvironment.CreateUri("Form_1.jpg");
#endif
AnalyzeDocumentOperation operation = await client.StartAnalyzeDocumentFromUriAsync("prebuilt-layout", fileUri);
await operation.WaitForCompletionAsync();
AnalyzeResult result = operation.Value;
foreach (DocumentPage page in result.Pages)
{
Console.WriteLine($"Document Page {page.PageNumber} has {page.Lines.Count} line(s), {page.Words.Count} word(s),");
Console.WriteLine($"and {page.SelectionMarks.Count} selection mark(s).");
for (int i = 0; i < page.Lines.Count; i++)
{
DocumentLine line = page.Lines[i];
Console.WriteLine($" Line {i} has content: '{line.Content}'.");
Console.WriteLine($" Its bounding box is:");
Console.WriteLine($" Upper left => X: {line.BoundingBox[0].X}, Y= {line.BoundingBox[0].Y}");
Console.WriteLine($" Upper right => X: {line.BoundingBox[1].X}, Y= {line.BoundingBox[1].Y}");
Console.WriteLine($" Lower right => X: {line.BoundingBox[2].X}, Y= {line.BoundingBox[2].Y}");
Console.WriteLine($" Lower left => X: {line.BoundingBox[3].X}, Y= {line.BoundingBox[3].Y}");
}
for (int i = 0; i < page.SelectionMarks.Count; i++)
{
DocumentSelectionMark selectionMark = page.SelectionMarks[i];
Console.WriteLine($" Selection Mark {i} is {selectionMark.State}.");
Console.WriteLine($" Its bounding box is:");
Console.WriteLine($" Upper left => X: {selectionMark.BoundingBox[0].X}, Y= {selectionMark.BoundingBox[0].Y}");
Console.WriteLine($" Upper right => X: {selectionMark.BoundingBox[1].X}, Y= {selectionMark.BoundingBox[1].Y}");
Console.WriteLine($" Lower right => X: {selectionMark.BoundingBox[2].X}, Y= {selectionMark.BoundingBox[2].Y}");
Console.WriteLine($" Lower left => X: {selectionMark.BoundingBox[3].X}, Y= {selectionMark.BoundingBox[3].Y}");
}
}
foreach (DocumentStyle style in result.Styles)
{
// Check the style and style confidence to see if text is handwritten.
// Note that value '0.8' is used as an example.
bool isHandwritten = style.IsHandwritten.HasValue && style.IsHandwritten == true;
if (isHandwritten && style.Confidence > 0.8)
{
Console.WriteLine($"Handwritten content found:");
foreach (DocumentSpan span in style.Spans)
{
Console.WriteLine($" Content: {result.Content.Substring(span.Offset, span.Length)}");
}
}
}
Console.WriteLine("The following tables were extracted:");
for (int i = 0; i < result.Tables.Count; i++)
{
DocumentTable table = result.Tables[i];
Console.WriteLine($" Table {i} has {table.RowCount} rows and {table.ColumnCount} columns.");
foreach (DocumentTableCell cell in table.Cells)
{
Console.WriteLine($" Cell ({cell.RowIndex}, {cell.ColumnIndex}) has kind '{cell.Kind}' and content: '{cell.Content}'.");
}
}
#endregion
}
public async Task ExtractLayoutFromFileAsync()
{
string endpoint = TestEnvironment.Endpoint;
string apiKey = TestEnvironment.ApiKey;
DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
#region Snippet:FormRecognizerExtractLayoutFromFileAsync
#if SNIPPET
string filePath = "<filePath>";
#else
string filePath = DocumentAnalysisTestEnvironment.CreatePath("Form_1.jpg");
#endif
using var stream = new FileStream(filePath, FileMode.Open);
AnalyzeDocumentOperation operation = await client.StartAnalyzeDocumentAsync("prebuilt-layout", stream);
await operation.WaitForCompletionAsync();
AnalyzeResult result = operation.Value;
foreach (DocumentPage page in result.Pages)
{
Console.WriteLine($"Document Page {page.PageNumber} has {page.Lines.Count} line(s), {page.Words.Count} word(s),");
Console.WriteLine($"and {page.SelectionMarks.Count} selection mark(s).");
for (int i = 0; i < page.Lines.Count; i++)
{
DocumentLine line = page.Lines[i];
Console.WriteLine($" Line {i} has content: '{line.Content}'.");
Console.WriteLine($" Its bounding polygon (points ordered clockwise):");
for (int j = 0; j < line.BoundingPolygon.Points.Length; j++)
{
Console.WriteLine($" Point {j} => X: {line.BoundingPolygon[j].X}, Y: {line.BoundingPolygon[j].Y}");
}
}
for (int i = 0; i < page.SelectionMarks.Count; i++)
{
DocumentSelectionMark selectionMark = page.SelectionMarks[i];
Console.WriteLine($" Selection Mark {i} is {selectionMark.State}.");
Console.WriteLine($" Its bounding polygon (points ordered clockwise):");
for (int j = 0; j < selectionMark.BoundingPolygon.Points.Length; j++)
{
Console.WriteLine($" Point {j} => X: {selectionMark.BoundingPolygon[j].X}, Y: {selectionMark.BoundingPolygon[j].Y}");
}
}
}
Console.WriteLine("Paragraphs:");
foreach (DocumentParagraph paragraph in result.Paragraphs)
{
Console.WriteLine($" Paragraph content: {paragraph.Content}");
if (paragraph.Role != null)
{
Console.WriteLine($" Role: {paragraph.Role}");
}
}
foreach (DocumentStyle style in result.Styles)
{
// Check the style and style confidence to see if text is handwritten.
// Note that value '0.8' is used as an example.
bool isHandwritten = style.IsHandwritten.HasValue && style.IsHandwritten == true;
if (isHandwritten && style.Confidence > 0.8)
{
Console.WriteLine($"Handwritten content found:");
foreach (DocumentSpan span in style.Spans)
{
Console.WriteLine($" Content: {result.Content.Substring(span.Offset, span.Length)}");
}
}
}
Console.WriteLine("The following tables were extracted:");
for (int i = 0; i < result.Tables.Count; i++)
{
DocumentTable table = result.Tables[i];
Console.WriteLine($" Table {i} has {table.RowCount} rows and {table.ColumnCount} columns.");
foreach (DocumentTableCell cell in table.Cells)
{
Console.WriteLine($" Cell ({cell.RowIndex}, {cell.ColumnIndex}) has kind '{cell.Kind}' and content: '{cell.Content}'.");
}
}
#endregion
}