控管處理回應

 import com.google.cloud.documentai.v1beta3.Document; import com.google.cloud.documentai.v1beta3.DocumentProcessorServiceClient; import com.google.cloud.documentai.v1beta3.DocumentProcessorServiceSettings; import com.google.cloud.documentai.v1beta3.ProcessRequest; import com.google.cloud.documentai.v1beta3.ProcessResponse; import com.google.cloud.documentai.v1beta3.RawDocument; import com.google.protobuf.ByteString; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; import java.util.List; import java.util.concurrent.ExecutionException; import java.util.concurrent.TimeoutException;  public class ProcessOcrDocument {   public static void processOcrDocument()       throws IOException, InterruptedException, ExecutionException, TimeoutException {     // TODO(developer): Replace these variables before running the sample.     String projectId = "your-project-id";     String location = "your-project-location"; // Format is "us" or "eu".     String processerId = "your-processor-id";     String filePath = "path/to/input/file.pdf";     processOcrDocument(projectId, location, processerId, filePath);   }    public static void processOcrDocument(       String projectId, String location, String processorId, String filePath)       throws IOException, InterruptedException, ExecutionException, TimeoutException {     // Initialize client that will be used to send requests. This client only needs     // to be created     // once, and can be reused for multiple requests. After completing all of your     // requests, call     // the "close" method on the client to safely clean up any remaining background     // resources.     String endpoint = String.format("%s-documentai.googleapis.com:443", location);     DocumentProcessorServiceSettings settings =         DocumentProcessorServiceSettings.newBuilder().setEndpoint(endpoint).build();     try (DocumentProcessorServiceClient client = DocumentProcessorServiceClient.create(settings)) {       // The full resource name of the processor, e.g.:       // projects/project-id/locations/location/processor/processor-id       // You must create new processors in the Cloud Console first       String name =           String.format("projects/%s/locations/%s/processors/%s", projectId, location, processorId);        // Read the file.       byte[] imageFileData = Files.readAllBytes(Paths.get(filePath));        // Convert the image data to a Buffer and base64 encode it.       ByteString content = ByteString.copyFrom(imageFileData);        RawDocument document =           RawDocument.newBuilder().setContent(content).setMimeType("application/pdf").build();        // Configure the process request.       ProcessRequest request =           ProcessRequest.newBuilder().setName(name).setRawDocument(document).build();        // Recognizes text entities in the PDF document       ProcessResponse result = client.processDocument(request);       Document documentResponse = result.getDocument();        System.out.println("Document processing complete.");        // Read the text recognition output from the processor       // For a full list of Document object attributes,       // please reference this page:       // https://googleapis.dev/java/google-cloud-document-ai/latest/index.html        // Get all of the document text as one big string       String text = documentResponse.getText();       System.out.printf("Full document text: '%s'\n", escapeNewlines(text));        // Read the text recognition output from the processor       List<Document.Page> pages = documentResponse.getPagesList();       System.out.printf("There are %s page(s) in this document.\n", pages.size());        for (Document.Page page : pages) {         System.out.printf("Page %d:\n", page.getPageNumber());         printPageDimensions(page.getDimension());         printDetectedLanguages(page.getDetectedLanguagesList());         printParagraphs(page.getParagraphsList(), text);         printBlocks(page.getBlocksList(), text);         printLines(page.getLinesList(), text);         printTokens(page.getTokensList(), text);       }     }   }    private static void printPageDimensions(Document.Page.Dimension dimension) {     String unit = dimension.getUnit();     System.out.printf("    Width: %.1f %s\n", dimension.getWidth(), unit);     System.out.printf("    Height: %.1f %s\n", dimension.getHeight(), unit);   }    private static void printDetectedLanguages(       List<Document.Page.DetectedLanguage> detectedLangauges) {     System.out.println("    Detected languages:");     for (Document.Page.DetectedLanguage detectedLanguage : detectedLangauges) {       String languageCode = detectedLanguage.getLanguageCode();       float confidence = detectedLanguage.getConfidence();       System.out.printf("        %s (%.2f%%)\n", languageCode, confidence * 100.0);     }   }    private static void printParagraphs(List<Document.Page.Paragraph> paragraphs, String text) {     System.out.printf("    %d paragraphs detected:\n", paragraphs.size());     Document.Page.Paragraph firstParagraph = paragraphs.get(0);     String firstParagraphText = getLayoutText(firstParagraph.getLayout().getTextAnchor(), text);     System.out.printf("        First paragraph text: %s\n", escapeNewlines(firstParagraphText));     Document.Page.Paragraph lastParagraph = paragraphs.get(paragraphs.size() - 1);     String lastParagraphText = getLayoutText(lastParagraph.getLayout().getTextAnchor(), text);     System.out.printf("        Last paragraph text: %s\n", escapeNewlines(lastParagraphText));   }    private static void printBlocks(List<Document.Page.Block> blocks, String text) {     System.out.printf("    %d blocks detected:\n", blocks.size());     Document.Page.Block firstBlock = blocks.get(0);     String firstBlockText = getLayoutText(firstBlock.getLayout().getTextAnchor(), text);     System.out.printf("        First block text: %s\n", escapeNewlines(firstBlockText));     Document.Page.Block lastBlock = blocks.get(blocks.size() - 1);     String lastBlockText = getLayoutText(lastBlock.getLayout().getTextAnchor(), text);     System.out.printf("        Last block text: %s\n", escapeNewlines(lastBlockText));   }    private static void printLines(List<Document.Page.Line> lines, String text) {     System.out.printf("    %d lines detected:\n", lines.size());     Document.Page.Line firstLine = lines.get(0);     String firstLineText = getLayoutText(firstLine.getLayout().getTextAnchor(), text);     System.out.printf("        First line text: %s\n", escapeNewlines(firstLineText));     Document.Page.Line lastLine = lines.get(lines.size() - 1);     String lastLineText = getLayoutText(lastLine.getLayout().getTextAnchor(), text);     System.out.printf("        Last line text: %s\n", escapeNewlines(lastLineText));   }    private static void printTokens(List<Document.Page.Token> tokens, String text) {     System.out.printf("    %d tokens detected:\n", tokens.size());     Document.Page.Token firstToken = tokens.get(0);     String firstTokenText = getLayoutText(firstToken.getLayout().getTextAnchor(), text);     System.out.printf("        First token text: %s\n", escapeNewlines(firstTokenText));     Document.Page.Token lastToken = tokens.get(tokens.size() - 1);     String lastTokenText = getLayoutText(lastToken.getLayout().getTextAnchor(), text);     System.out.printf("        Last token text: %s\n", escapeNewlines(lastTokenText));   }    // Extract shards from the text field   private static String getLayoutText(Document.TextAnchor textAnchor, String text) {     if (textAnchor.getTextSegmentsList().size() > 0) {       int startIdx = (int) textAnchor.getTextSegments(0).getStartIndex();       int endIdx = (int) textAnchor.getTextSegments(0).getEndIndex();       return text.substring(startIdx, endIdx);     }     return "[NO TEXT]";   }    private static String escapeNewlines(String s) {     return s.replace("\n", "\\n").replace("\r", "\\r");   } }

/**  * TODO(developer): Uncomment these variables before running the sample.  */ // const projectId = 'YOUR_PROJECT_ID'; // const location = 'YOUR_PROJECT_LOCATION'; // Format is 'us' or 'eu' // const processorId = 'YOUR_PROCESSOR_ID'; // Create processor in Cloud Console // const filePath = '/path/to/local/pdf';  const {DocumentProcessorServiceClient} =   require('@google-cloud/documentai').v1beta3;  // Instantiates a client const client = new DocumentProcessorServiceClient();  async function processDocument() {   // The full resource name of the processor, e.g.:   // projects/project-id/locations/location/processor/processor-id   // You must create new processors in the Cloud Console first   const name = `projects/${projectId}/locations/${location}/processors/${processorId}`;    // Read the file into memory.   const fs = require('fs').promises;   const imageFile = await fs.readFile(filePath);    // Convert the image data to a Buffer and base64 encode it.   const encodedImage = Buffer.from(imageFile).toString('base64');    const request = {     name,     rawDocument: {       content: encodedImage,       mimeType: 'application/pdf',     },   };    // Recognizes text entities in the PDF document   const [result] = await client.processDocument(request);    console.log('Document processing complete.');    // Read the text recognition output from the processor   // For a full list of Document object attributes,   // please reference this page: https://googleapis.dev/nodejs/documentai/latest/index.html   const {document} = result;   const {text} = document;    // Read the text recognition output from the processor   console.log(`Full document text: ${JSON.stringify(text)}`);   console.log(`There are ${document.pages.length} page(s) in this document.`);   for (const page of document.pages) {     console.log(`Page ${page.pageNumber}`);     printPageDimensions(page.dimension);     printDetectedLanguages(page.detectedLanguages);     printParagraphs(page.paragraphs, text);     printBlocks(page.blocks, text);     printLines(page.lines, text);     printTokens(page.tokens, text);   } }  const printPageDimensions = dimension => {   console.log(`    Width: ${dimension.width}`);   console.log(`    Height: ${dimension.height}`); };  const printDetectedLanguages = detectedLanguages => {   console.log('    Detected languages:');   for (const lang of detectedLanguages) {     const code = lang.languageCode;     const confPercent = lang.confidence * 100;     console.log(`        ${code} (${confPercent.toFixed(2)}% confidence)`);   } };  const printParagraphs = (paragraphs, text) => {   console.log(`    ${paragraphs.length} paragraphs detected:`);   const firstParagraphText = getText(paragraphs[0].layout.textAnchor, text);   console.log(     `        First paragraph text: ${JSON.stringify(firstParagraphText)}`   );   const lastParagraphText = getText(     paragraphs[paragraphs.length - 1].layout.textAnchor,     text   );   console.log(     `        Last paragraph text: ${JSON.stringify(lastParagraphText)}`   ); };  const printBlocks = (blocks, text) => {   console.log(`    ${blocks.length} blocks detected:`);   const firstBlockText = getText(blocks[0].layout.textAnchor, text);   console.log(`        First block text: ${JSON.stringify(firstBlockText)}`);   const lastBlockText = getText(     blocks[blocks.length - 1].layout.textAnchor,     text   );   console.log(`        Last block text: ${JSON.stringify(lastBlockText)}`); };  const printLines = (lines, text) => {   console.log(`    ${lines.length} lines detected:`);   const firstLineText = getText(lines[0].layout.textAnchor, text);   console.log(`        First line text: ${JSON.stringify(firstLineText)}`);   const lastLineText = getText(     lines[lines.length - 1].layout.textAnchor,     text   );   console.log(`        Last line text: ${JSON.stringify(lastLineText)}`); };  const printTokens = (tokens, text) => {   console.log(`    ${tokens.length} tokens detected:`);   const firstTokenText = getText(tokens[0].layout.textAnchor, text);   console.log(`        First token text: ${JSON.stringify(firstTokenText)}`);   const firstTokenBreakType = tokens[0].detectedBreak.type;   console.log(`        First token break type: ${firstTokenBreakType}`);   const lastTokenText = getText(     tokens[tokens.length - 1].layout.textAnchor,     text   );   console.log(`        Last token text: ${JSON.stringify(lastTokenText)}`);   const lastTokenBreakType = tokens[tokens.length - 1].detectedBreak.type;   console.log(`        Last token break type: ${lastTokenBreakType}`); };  // Extract shards from the text field const getText = (textAnchor, text) => {   if (!textAnchor.textSegments || textAnchor.textSegments.length === 0) {     return '';   }    // First shard in document doesn't have startIndex property   const startIndex = textAnchor.textSegments[0].startIndex || 0;   const endIndex = textAnchor.textSegments[0].endIndex;    return text.substring(startIndex, endIndex); }; 

 from typing import Optional, Sequence  from google.api_core.client_options import ClientOptions from google.cloud import documentai  # TODO(developer): Uncomment these variables before running the sample. # project_id = "YOUR_PROJECT_ID" # location = "YOUR_PROCESSOR_LOCATION" # Format is "us" or "eu" # processor_id = "YOUR_PROCESSOR_ID" # Create processor before running sample # processor_version = "rc" # Refer to https://cloud.google.com/document-ai/docs/manage-processor-versions for more information # file_path = "/path/to/local/pdf" # mime_type = "application/pdf" # Refer to https://cloud.google.com/document-ai/docs/file-types for supported file types   def process_document_ocr_sample(     project_id: str,     location: str,     processor_id: str,     processor_version: str,     file_path: str,     mime_type: str, ) -> None:     # Optional: Additional configurations for Document OCR Processor.     # For more information: https://cloud.google.com/document-ai/docs/enterprise-document-ocr     process_options = documentai.ProcessOptions(         ocr_config=documentai.OcrConfig(             enable_native_pdf_parsing=True,             enable_image_quality_scores=True,             enable_symbol=True,             # OCR Add Ons https://cloud.google.com/document-ai/docs/ocr-add-ons             premium_features=documentai.OcrConfig.PremiumFeatures(                 compute_style_info=True,                 enable_math_ocr=False,  # Enable to use Math OCR Model                 enable_selection_mark_detection=True,             ),         )     )     # Online processing request to Document AI     document = process_document(         project_id,         location,         processor_id,         processor_version,         file_path,         mime_type,         process_options=process_options,     )      text = document.text     print(f"Full document text: {text}\n")     print(f"There are {len(document.pages)} page(s) in this document.\n")      for page in document.pages:         print(f"Page {page.page_number}:")         print_page_dimensions(page.dimension)         print_detected_languages(page.detected_languages)          print_blocks(page.blocks, text)         print_paragraphs(page.paragraphs, text)         print_lines(page.lines, text)         print_tokens(page.tokens, text)          if page.symbols:             print_symbols(page.symbols, text)          if page.image_quality_scores:             print_image_quality_scores(page.image_quality_scores)          if page.visual_elements:             print_visual_elements(page.visual_elements, text)   def print_page_dimensions(dimension: documentai.Document.Page.Dimension) -> None:     print(f"    Width: {str(dimension.width)}")     print(f"    Height: {str(dimension.height)}")   def print_detected_languages(     detected_languages: Sequence[documentai.Document.Page.DetectedLanguage], ) -> None:     print("    Detected languages:")     for lang in detected_languages:         print(f"        {lang.language_code} ({lang.confidence:.1%} confidence)")   def print_blocks(blocks: Sequence[documentai.Document.Page.Block], text: str) -> None:     print(f"    {len(blocks)} blocks detected:")     first_block_text = layout_to_text(blocks[0].layout, text)     print(f"        First text block: {repr(first_block_text)}")     last_block_text = layout_to_text(blocks[-1].layout, text)     print(f"        Last text block: {repr(last_block_text)}")   def print_paragraphs(     paragraphs: Sequence[documentai.Document.Page.Paragraph], text: str ) -> None:     print(f"    {len(paragraphs)} paragraphs detected:")     first_paragraph_text = layout_to_text(paragraphs[0].layout, text)     print(f"        First paragraph text: {repr(first_paragraph_text)}")     last_paragraph_text = layout_to_text(paragraphs[-1].layout, text)     print(f"        Last paragraph text: {repr(last_paragraph_text)}")   def print_lines(lines: Sequence[documentai.Document.Page.Line], text: str) -> None:     print(f"    {len(lines)} lines detected:")     first_line_text = layout_to_text(lines[0].layout, text)     print(f"        First line text: {repr(first_line_text)}")     last_line_text = layout_to_text(lines[-1].layout, text)     print(f"        Last line text: {repr(last_line_text)}")   def print_tokens(tokens: Sequence[documentai.Document.Page.Token], text: str) -> None:     print(f"    {len(tokens)} tokens detected:")     first_token_text = layout_to_text(tokens[0].layout, text)     first_token_break_type = tokens[0].detected_break.type_.name     print(f"        First token text: {repr(first_token_text)}")     print(f"        First token break type: {repr(first_token_break_type)}")     if tokens[0].style_info:         print_style_info(tokens[0].style_info)      last_token_text = layout_to_text(tokens[-1].layout, text)     last_token_break_type = tokens[-1].detected_break.type_.name     print(f"        Last token text: {repr(last_token_text)}")     print(f"        Last token break type: {repr(last_token_break_type)}")     if tokens[-1].style_info:         print_style_info(tokens[-1].style_info)   def print_symbols(     symbols: Sequence[documentai.Document.Page.Symbol], text: str ) -> None:     print(f"    {len(symbols)} symbols detected:")     first_symbol_text = layout_to_text(symbols[0].layout, text)     print(f"        First symbol text: {repr(first_symbol_text)}")     last_symbol_text = layout_to_text(symbols[-1].layout, text)     print(f"        Last symbol text: {repr(last_symbol_text)}")   def print_image_quality_scores(     image_quality_scores: documentai.Document.Page.ImageQualityScores, ) -> None:     print(f"    Quality score: {image_quality_scores.quality_score:.1%}")     print("    Detected defects:")      for detected_defect in image_quality_scores.detected_defects:         print(f"        {detected_defect.type_}: {detected_defect.confidence:.1%}")   def print_style_info(style_info: documentai.Document.Page.Token.StyleInfo) -> None:     """     Only supported in version `pretrained-ocr-v2.0-2023-06-02`     """     print(f"           Font Size: {style_info.font_size}pt")     print(f"           Font Type: {style_info.font_type}")     print(f"           Bold: {style_info.bold}")     print(f"           Italic: {style_info.italic}")     print(f"           Underlined: {style_info.underlined}")     print(f"           Handwritten: {style_info.handwritten}")     print(         f"           Text Color (RGBa): {style_info.text_color.red}, {style_info.text_color.green}, {style_info.text_color.blue}, {style_info.text_color.alpha}"     )   def print_visual_elements(     visual_elements: Sequence[documentai.Document.Page.VisualElement], text: str ) -> None:     """     Only supported in version `pretrained-ocr-v2.0-2023-06-02`     """     checkboxes = [x for x in visual_elements if "checkbox" in x.type]     math_symbols = [x for x in visual_elements if x.type == "math_formula"]      if checkboxes:         print(f"    {len(checkboxes)} checkboxes detected:")         print(f"        First checkbox: {repr(checkboxes[0].type)}")         print(f"        Last checkbox: {repr(checkboxes[-1].type)}")      if math_symbols:         print(f"    {len(math_symbols)} math symbols detected:")         first_math_symbol_text = layout_to_text(math_symbols[0].layout, text)         print(f"        First math symbol: {repr(first_math_symbol_text)}")     def process_document(     project_id: str,     location: str,     processor_id: str,     processor_version: str,     file_path: str,     mime_type: str,     process_options: Optional[documentai.ProcessOptions] = None, ) -> documentai.Document:     # You must set the `api_endpoint` if you use a location other than "us".     client = documentai.DocumentProcessorServiceClient(         client_options=ClientOptions(             api_endpoint=f"{location}-documentai.googleapis.com"         )     )      # The full resource name of the processor version, e.g.:     # `projects/{project_id}/locations/{location}/processors/{processor_id}/processorVersions/{processor_version_id}`     # You must create a processor before running this sample.     name = client.processor_version_path(         project_id, location, processor_id, processor_version     )      # Read the file into memory     with open(file_path, "rb") as image:         image_content = image.read()      # Configure the process request     request = documentai.ProcessRequest(         name=name,         raw_document=documentai.RawDocument(content=image_content, mime_type=mime_type),         # Only supported for Document OCR processor         process_options=process_options,     )      result = client.process_document(request=request)      # For a full list of `Document` object attributes, reference this page:     # https://cloud.google.com/document-ai/docs/reference/rest/v1/Document     return result.document     def layout_to_text(layout: documentai.Document.Page.Layout, text: str) -> str:     """     Document AI identifies text in different parts of the document by their     offsets in the entirety of the document"s text. This function converts     offsets to a string.     """     # If a text segment spans several lines, it will     # be stored in different text segments.     return "".join(         text[int(segment.start_index) : int(segment.end_index)]         for segment in layout.text_anchor.text_segments     )  

 import com.google.cloud.documentai.v1beta3.Document; import com.google.cloud.documentai.v1beta3.DocumentProcessorServiceClient; import com.google.cloud.documentai.v1beta3.DocumentProcessorServiceSettings; import com.google.cloud.documentai.v1beta3.ProcessRequest; import com.google.cloud.documentai.v1beta3.ProcessResponse; import com.google.cloud.documentai.v1beta3.RawDocument; import com.google.protobuf.ByteString; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; import java.util.List; import java.util.concurrent.ExecutionException; import java.util.concurrent.TimeoutException;  public class ProcessFormDocument {   public static void processFormDocument()       throws IOException, InterruptedException, ExecutionException, TimeoutException {     // TODO(developer): Replace these variables before running the sample.     String projectId = "your-project-id";     String location = "your-project-location"; // Format is "us" or "eu".     String processerId = "your-processor-id";     String filePath = "path/to/input/file.pdf";     processFormDocument(projectId, location, processerId, filePath);   }    public static void processFormDocument(       String projectId, String location, String processorId, String filePath)       throws IOException, InterruptedException, ExecutionException, TimeoutException {     // Initialize client that will be used to send requests. This client only needs     // to be created     // once, and can be reused for multiple requests. After completing all of your     // requests, call     // the "close" method on the client to safely clean up any remaining background     // resources.     String endpoint = String.format("%s-documentai.googleapis.com:443", location);     DocumentProcessorServiceSettings settings =         DocumentProcessorServiceSettings.newBuilder().setEndpoint(endpoint).build();     try (DocumentProcessorServiceClient client = DocumentProcessorServiceClient.create(settings)) {       // The full resource name of the processor, e.g.:       // projects/project-id/locations/location/processor/processor-id       // You must create new processors in the Cloud Console first       String name =           String.format("projects/%s/locations/%s/processors/%s", projectId, location, processorId);        // Read the file.       byte[] imageFileData = Files.readAllBytes(Paths.get(filePath));        // Convert the image data to a Buffer and base64 encode it.       ByteString content = ByteString.copyFrom(imageFileData);        RawDocument document =           RawDocument.newBuilder().setContent(content).setMimeType("application/pdf").build();        // Configure the process request.       ProcessRequest request =           ProcessRequest.newBuilder().setName(name).setRawDocument(document).build();        // Recognizes text entities in the PDF document       ProcessResponse result = client.processDocument(request);       Document documentResponse = result.getDocument();        System.out.println("Document processing complete.");        // Read the text recognition output from the processor       // For a full list of Document object attributes,       // please reference this page:       // https://googleapis.dev/java/google-cloud-document-ai/latest/index.html        // Get all of the document text as one big string       String text = documentResponse.getText();       System.out.printf("Full document text: '%s'\n", removeNewlines(text));        // Read the text recognition output from the processor       List<Document.Page> pages = documentResponse.getPagesList();       System.out.printf("There are %s page(s) in this document.\n", pages.size());        for (Document.Page page : pages) {         System.out.printf("\n\n**** Page %d ****\n", page.getPageNumber());          List<Document.Page.Table> tables = page.getTablesList();         System.out.printf("Found %d table(s):\n", tables.size());         for (Document.Page.Table table : tables) {           printTableInfo(table, text);         }          List<Document.Page.FormField> formFields = page.getFormFieldsList();         System.out.printf("Found %d form fields:\n", formFields.size());         for (Document.Page.FormField formField : formFields) {           String fieldName = getLayoutText(formField.getFieldName().getTextAnchor(), text);           String fieldValue = getLayoutText(formField.getFieldValue().getTextAnchor(), text);           System.out.printf(               "    * '%s': '%s'\n", removeNewlines(fieldName), removeNewlines(fieldValue));         }       }     }   }    private static void printTableInfo(Document.Page.Table table, String text) {     Document.Page.Table.TableRow firstBodyRow = table.getBodyRows(0);     int columnCount = firstBodyRow.getCellsCount();     System.out.printf(         "    Table with %d columns and %d rows:\n", columnCount, table.getBodyRowsCount());      Document.Page.Table.TableRow headerRow = table.getHeaderRows(0);     StringBuilder headerRowText = new StringBuilder();     for (Document.Page.Table.TableCell cell : headerRow.getCellsList()) {       String columnName = getLayoutText(cell.getLayout().getTextAnchor(), text);       headerRowText.append(String.format("%s | ", removeNewlines(columnName)));     }     headerRowText.setLength(headerRowText.length() - 3);     System.out.printf("        Collumns: %s\n", headerRowText.toString());      StringBuilder firstRowText = new StringBuilder();     for (Document.Page.Table.TableCell cell : firstBodyRow.getCellsList()) {       String cellText = getLayoutText(cell.getLayout().getTextAnchor(), text);       firstRowText.append(String.format("%s | ", removeNewlines(cellText)));     }     firstRowText.setLength(firstRowText.length() - 3);     System.out.printf("        First row data: %s\n", firstRowText.toString());   }    // Extract shards from the text field   private static String getLayoutText(Document.TextAnchor textAnchor, String text) {     if (textAnchor.getTextSegmentsList().size() > 0) {       int startIdx = (int) textAnchor.getTextSegments(0).getStartIndex();       int endIdx = (int) textAnchor.getTextSegments(0).getEndIndex();       return text.substring(startIdx, endIdx);     }     return "[NO TEXT]";   }    private static String removeNewlines(String s) {     return s.replace("\n", "").replace("\r", "");   } }

/**  * TODO(developer): Uncomment these variables before running the sample.  */ // const projectId = 'YOUR_PROJECT_ID'; // const location = 'YOUR_PROJECT_LOCATION'; // Format is 'us' or 'eu' // const processorId = 'YOUR_PROCESSOR_ID'; // Create processor in Cloud Console // const filePath = '/path/to/local/pdf';  const {DocumentProcessorServiceClient} =   require('@google-cloud/documentai').v1beta3;  // Instantiates a client const client = new DocumentProcessorServiceClient();  async function processDocument() {   // The full resource name of the processor, e.g.:   // projects/project-id/locations/location/processor/processor-id   // You must create new processors in the Cloud Console first   const name = `projects/${projectId}/locations/${location}/processors/${processorId}`;    // Read the file into memory.   const fs = require('fs').promises;   const imageFile = await fs.readFile(filePath);    // Convert the image data to a Buffer and base64 encode it.   const encodedImage = Buffer.from(imageFile).toString('base64');    const request = {     name,     rawDocument: {       content: encodedImage,       mimeType: 'application/pdf',     },   };    // Recognizes text entities in the PDF document   const [result] = await client.processDocument(request);    console.log('Document processing complete.');    // Read the table and form fields output from the processor   // The form processor also contains OCR data. For more information   // on how to parse OCR data please see the OCR sample.   // For a full list of Document object attributes,   // please reference this page: https://googleapis.dev/nodejs/documentai/latest/index.html   const {document} = result;   const {text} = document;   console.log(`Full document text: ${JSON.stringify(text)}`);   console.log(`There are ${document.pages.length} page(s) in this document.`);    for (const page of document.pages) {     console.log(`\n\n**** Page ${page.pageNumber} ****`);      console.log(`Found ${page.tables.length} table(s):`);     for (const table of page.tables) {       const numCollumns = table.headerRows[0].cells.length;       const numRows = table.bodyRows.length;       console.log(`Table with ${numCollumns} columns and ${numRows} rows:`);       printTableInfo(table, text);     }     console.log(`Found ${page.formFields.length} form field(s):`);     for (const field of page.formFields) {       const fieldName = getText(field.fieldName.textAnchor, text);       const fieldValue = getText(field.fieldValue.textAnchor, text);       console.log(         `\t* ${JSON.stringify(fieldName)}: ${JSON.stringify(fieldValue)}`       );     }   } }  const printTableInfo = (table, text) => {   // Print header row   let headerRowText = '';   for (const headerCell of table.headerRows[0].cells) {     const headerCellText = getText(headerCell.layout.textAnchor, text);     headerRowText += `${JSON.stringify(headerCellText.trim())} | `;   }   console.log(     `Collumns: ${headerRowText.substring(0, headerRowText.length - 3)}`   );   // Print first body row   let bodyRowText = '';   for (const bodyCell of table.bodyRows[0].cells) {     const bodyCellText = getText(bodyCell.layout.textAnchor, text);     bodyRowText += `${JSON.stringify(bodyCellText.trim())} | `;   }   console.log(     `First row data: ${bodyRowText.substring(0, bodyRowText.length - 3)}`   ); };  // Extract shards from the text field const getText = (textAnchor, text) => {   if (!textAnchor.textSegments || textAnchor.textSegments.length === 0) {     return '';   }    // First shard in document doesn't have startIndex property   const startIndex = textAnchor.textSegments[0].startIndex || 0;   const endIndex = textAnchor.textSegments[0].endIndex;    return text.substring(startIndex, endIndex); }; 

 from typing import Optional, Sequence  from google.api_core.client_options import ClientOptions from google.cloud import documentai  # TODO(developer): Uncomment these variables before running the sample. # project_id = "YOUR_PROJECT_ID" # location = "YOUR_PROCESSOR_LOCATION" # Format is "us" or "eu" # processor_id = "YOUR_PROCESSOR_ID" # Create processor before running sample # processor_version = "rc" # Refer to https://cloud.google.com/document-ai/docs/manage-processor-versions for more information # file_path = "/path/to/local/pdf" # mime_type = "application/pdf" # Refer to https://cloud.google.com/document-ai/docs/file-types for supported file types   def process_document_form_sample(     project_id: str,     location: str,     processor_id: str,     processor_version: str,     file_path: str,     mime_type: str, ) -> documentai.Document:     # Online processing request to Document AI     document = process_document(         project_id, location, processor_id, processor_version, file_path, mime_type     )      # Read the table and form fields output from the processor     # The form processor also contains OCR data. For more information     # on how to parse OCR data please see the OCR sample.      text = document.text     print(f"Full document text: {repr(text)}\n")     print(f"There are {len(document.pages)} page(s) in this document.")      # Read the form fields and tables output from the processor     for page in document.pages:         print(f"\n\n**** Page {page.page_number} ****")          print(f"\nFound {len(page.tables)} table(s):")         for table in page.tables:             num_columns = len(table.header_rows[0].cells)             num_rows = len(table.body_rows)             print(f"Table with {num_columns} columns and {num_rows} rows:")              # Print header rows             print("Columns:")             print_table_rows(table.header_rows, text)             # Print body rows             print("Table body data:")             print_table_rows(table.body_rows, text)          print(f"\nFound {len(page.form_fields)} form field(s):")         for field in page.form_fields:             name = layout_to_text(field.field_name, text)             value = layout_to_text(field.field_value, text)             print(f"    * {repr(name.strip())}: {repr(value.strip())}")      # Supported in version `pretrained-form-parser-v2.0-2022-11-10` and later.     # For more information: https://cloud.google.com/document-ai/docs/form-parser     if document.entities:         print(f"Found {len(document.entities)} generic entities:")         for entity in document.entities:             print_entity(entity)             # Print Nested Entities             for prop in entity.properties:                 print_entity(prop)      return document   def print_table_rows(     table_rows: Sequence[documentai.Document.Page.Table.TableRow], text: str ) -> None:     for table_row in table_rows:         row_text = ""         for cell in table_row.cells:             cell_text = layout_to_text(cell.layout, text)             row_text += f"{repr(cell_text.strip())} | "         print(row_text)     def print_entity(entity: documentai.Document.Entity) -> None:     # Fields detected. For a full list of fields for each processor see     # the processor documentation:     # https://cloud.google.com/document-ai/docs/processors-list     key = entity.type_      # Some other value formats in addition to text are available     # e.g. dates: `entity.normalized_value.date_value.year`     text_value = entity.text_anchor.content or entity.mention_text     confidence = entity.confidence     normalized_value = entity.normalized_value.text     print(f"    * {repr(key)}: {repr(text_value)} ({confidence:.1%} confident)")      if normalized_value:         print(f"    * Normalized Value: {repr(normalized_value)}")     def process_document(     project_id: str,     location: str,     processor_id: str,     processor_version: str,     file_path: str,     mime_type: str,     process_options: Optional[documentai.ProcessOptions] = None, ) -> documentai.Document:     # You must set the `api_endpoint` if you use a location other than "us".     client = documentai.DocumentProcessorServiceClient(         client_options=ClientOptions(             api_endpoint=f"{location}-documentai.googleapis.com"         )     )      # The full resource name of the processor version, e.g.:     # `projects/{project_id}/locations/{location}/processors/{processor_id}/processorVersions/{processor_version_id}`     # You must create a processor before running this sample.     name = client.processor_version_path(         project_id, location, processor_id, processor_version     )      # Read the file into memory     with open(file_path, "rb") as image:         image_content = image.read()      # Configure the process request     request = documentai.ProcessRequest(         name=name,         raw_document=documentai.RawDocument(content=image_content, mime_type=mime_type),         # Only supported for Document OCR processor         process_options=process_options,     )      result = client.process_document(request=request)      # For a full list of `Document` object attributes, reference this page:     # https://cloud.google.com/document-ai/docs/reference/rest/v1/Document     return result.document     def layout_to_text(layout: documentai.Document.Page.Layout, text: str) -> str:     """     Document AI identifies text in different parts of the document by their     offsets in the entirety of the document"s text. This function converts     offsets to a string.     """     # If a text segment spans several lines, it will     # be stored in different text segments.     return "".join(         text[int(segment.start_index) : int(segment.end_index)]         for segment in layout.text_anchor.text_segments     )  

 import com.google.cloud.documentai.v1beta3.Document; import com.google.cloud.documentai.v1beta3.DocumentProcessorServiceClient; import com.google.cloud.documentai.v1beta3.DocumentProcessorServiceSettings; import com.google.cloud.documentai.v1beta3.ProcessRequest; import com.google.cloud.documentai.v1beta3.ProcessResponse; import com.google.cloud.documentai.v1beta3.RawDocument; import com.google.protobuf.ByteString; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; import java.util.concurrent.ExecutionException; import java.util.concurrent.TimeoutException;  public class ProcessSpecializedDocument {   public static void processSpecializedDocument()       throws IOException, InterruptedException, ExecutionException, TimeoutException {     // TODO(developer): Replace these variables before running the sample.     String projectId = "your-project-id";     String location = "your-project-location"; // Format is "us" or "eu".     String processerId = "your-processor-id";     String filePath = "path/to/input/file.pdf";     processSpecializedDocument(projectId, location, processerId, filePath);   }    public static void processSpecializedDocument(       String projectId, String location, String processorId, String filePath)       throws IOException, InterruptedException, ExecutionException, TimeoutException {     // Initialize client that will be used to send requests. This client only needs     // to be created     // once, and can be reused for multiple requests. After completing all of your     // requests, call     // the "close" method on the client to safely clean up any remaining background     // resources.     String endpoint = String.format("%s-documentai.googleapis.com:443", location);     DocumentProcessorServiceSettings settings =         DocumentProcessorServiceSettings.newBuilder().setEndpoint(endpoint).build();     try (DocumentProcessorServiceClient client = DocumentProcessorServiceClient.create(settings)) {       // The full resource name of the processor, e.g.:       // projects/project-id/locations/location/processor/processor-id       // You must create new processors in the Cloud Console first       String name =           String.format("projects/%s/locations/%s/processors/%s", projectId, location, processorId);        // Read the file.       byte[] imageFileData = Files.readAllBytes(Paths.get(filePath));        // Convert the image data to a Buffer and base64 encode it.       ByteString content = ByteString.copyFrom(imageFileData);        RawDocument document =           RawDocument.newBuilder().setContent(content).setMimeType("application/pdf").build();        // Configure the process request.       ProcessRequest request =           ProcessRequest.newBuilder().setName(name).setRawDocument(document).build();        // Recognizes text entities in the PDF document       ProcessResponse result = client.processDocument(request);       Document documentResponse = result.getDocument();        System.out.println("Document processing complete.");        // Read fields specificly from the specalized US drivers license processor:       // https://cloud.google.com/document-ai/docs/processors-list#processor_us-driver-license-parser       // retriving data from other specalized processors follow a similar pattern.       // For a complete list of processors see:       // https://cloud.google.com/document-ai/docs/processors-list       //       // OCR and other data is also present in the quality processor's response.       // Please see the OCR and other samples for how to parse other data in the       // response.       for (Document.Entity entity : documentResponse.getEntitiesList()) {         // Fields detected. For a full list of fields for each processor see         // the processor documentation:         // https://cloud.google.com/document-ai/docs/processors-list         String entityType = entity.getType();         // some other value formats in addition to text are availible         // e.g. dates: `entity.getNormalizedValue().getDateValue().getYear()`         // check for normilized value with `entity.hasNormalizedValue()`         String entityTextValue = escapeNewlines(entity.getTextAnchor().getContent());         float entityConfidence = entity.getConfidence();         System.out.printf(             "    * %s: %s (%.2f%% confident)\n",             entityType, entityTextValue, entityConfidence * 100.0);       }     }   }    private static String escapeNewlines(String s) {     return s.replace("\n", "\\n").replace("\r", "\\r");   } }