Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Tutorial [Block](API_Block.md)gli oggetti restituiti dalle operazioni Amazon Textract contengono i risultati delle operazioni di rilevamento del testo e analisi del testo, ad esempio[AnalyzeDocument](API_AnalyzeDocument.md). Le seguenti esercitazioni Python mostrano alcuni modi diversi in cui è possibile utilizzare gli oggetti Block. Ad esempio, è possibile esportare le informazioni della tabella in un file (CSV) con valori separati dalla virgola. I tutorial utilizzano operazioni di Amazon Textract sincrone che restituiscono tutti i risultati. Se si desidera utilizzare operazioni asincrone come[StartDocumentAnalysis](API_StartDocumentAnalysis.md), è necessario modificare il codice di esempio per ospitare più batch di restituiti`Block`oggetti. Per utilizzare l'esempio di operazioni asincrone, assicurarsi di aver seguito le istruzioni fornite all'indirizzo[Configurazione di Amazon Textract per operazioni asincrone](api-async-roles.md). Per esempi che mostrano altri modi di utilizzare Amazon Textract, consulta[Esempi di codice aggiuntivo](other-examples.md). **Topics** + [Prerequisiti](#examples-prerequisites) + [Estrazione di coppie chiave-valore da un documento modulo](examples-extract-kvp.md) + [Esportazione di tabelle in un file CSV](examples-export-table-csv.md) + [Creazione di unAWS LambdaFunzione](lambda.md) + [Esempi di codice aggiuntivo](other-examples.md) ## Prerequisiti Prima di eseguire gli esempi in questa sezione, è necessario configurare l'ambiente. **Per configurare l'ambiente** 1. Creazione o aggiornamento di un utente IAM con`AmazonTextractFullAccess`autorizzazioni. Per ulteriori informazioni, consultare [Fase 1: Impostazione di un account AWS e creazione di un utente IAM](setting-up.md#setting-up-iam). 1. Installa e configura la AWS CLI e gli SDK AWS. Per ulteriori informazioni, consultare [Fase 2: Configurazione diAWS CLIeAWSSDK](setup-awscli-sdk.md). # Estrazione di coppie chiave-valore da un documento modulo L'esempio Python seguente mostra come estrarre coppie chiave-valore nei documenti del modulo[Block](API_Block.md)oggetti memorizzati in una mappa. Gli oggetti bloccati vengono restituiti da una chiamata a[AnalyzeDocument](API_AnalyzeDocument.md). Per ulteriori informazioni, consultare [Dati del modulo (coppie chiave-valore)](how-it-works-kvp.md). Si utilizzano le seguenti funzioni: + `get_kv_map`— Chiama[AnalyzeDocument](API_AnalyzeDocument.md)e memorizza gli oggetti KEY e VALUE BLOCK in una mappa. + `get_kv_relationship`e`find_value_block`— Costruisce le relazioni chiave-valore dalla mappa. **Per estrarre coppie chiave-valore da un documento di modulo** 1. Configura l'ambiente. Per ulteriori informazioni, consultare [Prerequisiti](examples-blocks.md#examples-prerequisites). 1. Salvare il seguente codice di esempio in un file denominato*textract\$1python\$1kv\$1parser.py*. ``` import boto3 import sys import re import json def get_kv_map(file_name): with open(file_name, 'rb') as file: img_test = file.read() bytes_test = bytearray(img_test) print('Image loaded', file_name) # process using image bytes client = boto3.client('textract') response = client.analyze_document(Document={'Bytes': bytes_test}, FeatureTypes=['FORMS']) # Get the text blocks blocks=response['Blocks'] # get key and value maps key_map = {} value_map = {} block_map = {} for block in blocks: block_id = block['Id'] block_map[block_id] = block if block['BlockType'] == "KEY_VALUE_SET": if 'KEY' in block['EntityTypes']: key_map[block_id] = block else: value_map[block_id] = block return key_map, value_map, block_map def get_kv_relationship(key_map, value_map, block_map): kvs = {} for block_id, key_block in key_map.items(): value_block = find_value_block(key_block, value_map) key = get_text(key_block, block_map) val = get_text(value_block, block_map) kvs[key] = val return kvs def find_value_block(key_block, value_map): for relationship in key_block['Relationships']: if relationship['Type'] == 'VALUE': for value_id in relationship['Ids']: value_block = value_map[value_id] return value_block def get_text(result, blocks_map): text = '' if 'Relationships' in result: for relationship in result['Relationships']: if relationship['Type'] == 'CHILD': for child_id in relationship['Ids']: word = blocks_map[child_id] if word['BlockType'] == 'WORD': text += word['Text'] + ' ' if word['BlockType'] == 'SELECTION_ELEMENT': if word['SelectionStatus'] == 'SELECTED': text += 'X ' return text def print_kvs(kvs): for key, value in kvs.items(): print(key, ":", value) def search_value(kvs, search_key): for key, value in kvs.items(): if re.search(search_key, key, re.IGNORECASE): return value def main(file_name): key_map, value_map, block_map = get_kv_map(file_name) # Get Key Value relationship kvs = get_kv_relationship(key_map, value_map, block_map) print("\n\n== FOUND KEY : VALUE pairs ===\n") print_kvs(kvs) # Start searching a key value while input('\n Do you want to search a value for a key? (enter "n" for exit) ') != 'n': search_key = input('\n Enter a search key:') print('The value is:', search_value(kvs, search_key)) if __name__ == "__main__": file_name = sys.argv[1] main(file_name) ``` 1. Al prompt dei comandi inserisci il comando seguente: Replace (Sostituisci)`file`con il file immagine del documento che vuoi analizzare. ``` textract_python_kv_parser.py file ``` 1. Quando viene richiesto, immettere una chiave presente nel documento di input. Se il codice rileva la chiave, viene visualizzato il valore della chiave. # Esportazione di tabelle in un file CSV In questi esempi Python viene illustrato come esportare tabelle da un'immagine di un documento in un file (CSV) con valori separati dalla virgola. L'esempio per l'analisi sincrona dei documenti raccoglie le informazioni della tabella da una chiamata a[AnalyzeDocument](API_AnalyzeDocument.md). L'esempio per l'analisi asincrona dei documenti effettua una chiamata a[StartDocumentAnalysis](API_StartDocumentAnalysis.md)e quindi recupera i risultati da[GetDocumentAnalysis](API_GetDocumentAnalysis.md)come`Block`oggetti. Le informazioni sulla tabella vengono restituite come[Block](API_Block.md)oggetti da una chiamata a[AnalyzeDocument](API_AnalyzeDocument.md). Per ulteriori informazioni, consultare [Tabelle](how-it-works-tables.md). La`Block`gli oggetti vengono memorizzati in una struttura mappa utilizzata per esportare i dati della tabella in un file CSV. ------ #### [ Synchronous ] In questo esempio, utilizzerai le funzioni: + `get_table_csv_results`— Chiama[AnalyzeDocument](API_AnalyzeDocument.md)e crea una mappa di tabelle rilevate nel documento. Crea una rappresentazione CSV di tutte le tabelle rilevate. + `generate_table_csv`— Genera il file CSV per una singola tabella. + `get_rows_columns_map`— Ottiene le righe e le colonne dalla mappa. + `get_text`— Ottiene il testo da una cella. **Per esportare le tabelle in un file CSV** 1. Configura l'ambiente. Per ulteriori informazioni, consultare [Prerequisiti](examples-blocks.md#examples-prerequisites). 1. Salvare il seguente codice di esempio in un file denominato*textract\$1python\$1table\$1parser.py*. ``` import webbrowser, os import json import boto3 import io from io import BytesIO import sys from pprint import pprint def get_rows_columns_map(table_result, blocks_map): rows = {} for relationship in table_result['Relationships']: if relationship['Type'] == 'CHILD': for child_id in relationship['Ids']: cell = blocks_map[child_id] if cell['BlockType'] == 'CELL': row_index = cell['RowIndex'] col_index = cell['ColumnIndex'] if row_index not in rows: # create new row rows[row_index] = {} # get the text value rows[row_index][col_index] = get_text(cell, blocks_map) return rows def get_text(result, blocks_map): text = '' if 'Relationships' in result: for relationship in result['Relationships']: if relationship['Type'] == 'CHILD': for child_id in relationship['Ids']: word = blocks_map[child_id] if word['BlockType'] == 'WORD': text += word['Text'] + ' ' if word['BlockType'] == 'SELECTION_ELEMENT': if word['SelectionStatus'] =='SELECTED': text += 'X ' return text def get_table_csv_results(file_name): with open(file_name, 'rb') as file: img_test = file.read() bytes_test = bytearray(img_test) print('Image loaded', file_name) # process using image bytes # get the results client = boto3.client('textract') response = client.analyze_document(Document={'Bytes': bytes_test}, FeatureTypes=['TABLES']) # Get the text blocks blocks=response['Blocks'] pprint(blocks) blocks_map = {} table_blocks = [] for block in blocks: blocks_map[block['Id']] = block if block['BlockType'] == "TABLE": table_blocks.append(block) if len(table_blocks) <= 0: return " NO Table FOUND " csv = '' for index, table in enumerate(table_blocks): csv += generate_table_csv(table, blocks_map, index +1) csv += '\n\n' return csv def generate_table_csv(table_result, blocks_map, table_index): rows = get_rows_columns_map(table_result, blocks_map) table_id = 'Table_' + str(table_index) # get cells. csv = 'Table: {0}\n\n'.format(table_id) for row_index, cols in rows.items(): for col_index, text in cols.items(): csv += '{}'.format(text) + "," csv += '\n' csv += '\n\n\n' return csv def main(file_name): table_csv = get_table_csv_results(file_name) output_file = 'output.csv' # replace content with open(output_file, "wt") as fout: fout.write(table_csv) # show the results print('CSV OUTPUT FILE: ', output_file) if __name__ == "__main__": file_name = sys.argv[1] main(file_name) ``` 1. Al prompt dei comandi inserisci il comando seguente: Replace (Sostituisci)`file`con il nome del file immagine del documento che si desidera analizzare. ``` python textract_python_table_parser.py file ``` Quando si esegue l'esempio, l'output CSV viene salvato in un file denominato`output.csv`. ------ #### [ Asynchronous ] In questo esempio, utilizzerai due script diversi. Il primo script avvia il processo di analisi asincrona dei documenti con`StartDocumentAnalysis`e ottiene il`Block`informazioni restituite da`GetDocumentAnalysis`. Il secondo script prende il valore restituito`Block`informazioni per ogni pagina, formatta i dati come tabella e salva le tabelle in un file CSV. **Per esportare le tabelle in un file CSV** 1. Configura l'ambiente. Per ulteriori informazioni, consultare [Prerequisiti](examples-blocks.md#examples-prerequisites). 1. Assicurati di aver seguito le istruzioni fornite a vedi[Configurazione di Amazon Textract per operazioni asincrone](api-async-roles.md). Il processo documentato in quella pagina consente di inviare e ricevere messaggi sullo stato di completamento dei processi asincroni. 1. Nel seguente esempio di codice, sostituire il valore di`roleArn`con l'Arn assegnato al ruolo creato nella fase 2. Sostituisci il valore di`bucket`con il nome del bucket S3 contenente il documento. Sostituisci il valore di`document`con il nome del documento nel bucket S3. Sostituisci il valore di`region_name`con il nome della regione del bucket. Salvare il seguente codice di esempio in un file denominato*start\$1doc\$1analysis\$1for\$1table\$1extraction.py.*. ``` import boto3 import time class DocumentProcessor: jobId = '' region_name = '' roleArn = '' bucket = '' document = '' sqsQueueUrl = '' snsTopicArn = '' processType = '' def __init__(self, role, bucket, document, region): self.roleArn = role self.bucket = bucket self.document = document self.region_name = region self.textract = boto3.client('textract', region_name=self.region_name) self.sqs = boto3.client('sqs') self.sns = boto3.client('sns') def ProcessDocument(self): jobFound = False response = self.textract.start_document_analysis(DocumentLocation={'S3Object': {'Bucket': self.bucket, 'Name': self.document}}, FeatureTypes=["TABLES", "FORMS"], NotificationChannel={'RoleArn': self.roleArn, 'SNSTopicArn': self.snsTopicArn}) print('Processing type: Analysis') print('Start Job Id: ' + response['JobId']) print('Done!') def CreateTopicandQueue(self): millis = str(int(round(time.time() * 1000))) # Create SNS topic snsTopicName = "AmazonTextractTopic" + millis topicResponse = self.sns.create_topic(Name=snsTopicName) self.snsTopicArn = topicResponse['TopicArn'] # create SQS queue sqsQueueName = "AmazonTextractQueue" + millis self.sqs.create_queue(QueueName=sqsQueueName) self.sqsQueueUrl = self.sqs.get_queue_url(QueueName=sqsQueueName)['QueueUrl'] attribs = self.sqs.get_queue_attributes(QueueUrl=self.sqsQueueUrl, AttributeNames=['QueueArn'])['Attributes'] sqsQueueArn = attribs['QueueArn'] # Subscribe SQS queue to SNS topic self.sns.subscribe(TopicArn=self.snsTopicArn, Protocol='sqs', Endpoint=sqsQueueArn) # Authorize SNS to write SQS queue policy = """{{ "Version":"2012-10-17", "Statement":[ {{ "Sid":"MyPolicy", "Effect":"Allow", "Principal" : {{"AWS" : "*"}}, "Action":"SQS:SendMessage", "Resource": "{}", "Condition":{{ "ArnEquals":{{ "aws:SourceArn": "{}" }} }} }} ] }}""".format(sqsQueueArn, self.snsTopicArn) response = self.sqs.set_queue_attributes( QueueUrl=self.sqsQueueUrl, Attributes={ 'Policy': policy }) def main(): roleArn = 'role-arn' bucket = 'bucket-name' document = 'document-name' region_name = 'region-name' analyzer = DocumentProcessor(roleArn, bucket, document, region_name) analyzer.CreateTopicandQueue() analyzer.ProcessDocument() if __name__ == "__main__": main() ``` 1. Eseguire il codice. Il codice stamperà un JobId. Copia questo JobId. 1. Attendi che il lavoro finisca l'elaborazione e, una volta terminato, copia il seguente codice in un file denominato*get\$1doc\$1analysis\$1for\$1table\$1extraction.py*. Sostituisci il valore di`jobId`con il Job ID copiato in precedenza. Sostituisci il valore di`region_name`con il nome della regione associata al ruolo Textract. Sostituisci il valore di`file_name`con il nome da assegnare all'output CSV. ``` import boto3 from pprint import pprint jobId = 'job-id' region_name = 'region-name' file_name = "output-file-name.csv" textract = boto3.client('textract', region_name=region_name) # Display information about a block def DisplayBlockInfo(block): print("Block Id: " + block['Id']) print("Type: " + block['BlockType']) if 'EntityTypes' in block: print('EntityTypes: {}'.format(block['EntityTypes'])) if 'Text' in block: print("Text: " + block['Text']) if block['BlockType'] != 'PAGE': print("Confidence: " + "{:.2f}".format(block['Confidence']) + "%") def GetResults(jobId, file_name): maxResults = 1000 paginationToken = None finished = False while finished == False: response = None if paginationToken == None: response = textract.get_document_analysis(JobId=jobId, MaxResults=maxResults) else: response = textract.get_document_analysis(JobId=jobId, MaxResults=maxResults, NextToken=paginationToken) blocks = response['Blocks'] table_csv = get_table_csv_results(blocks) output_file = file_name # replace content with open(output_file, "at") as fout: fout.write(table_csv) # show the results print('Detected Document Text') print('Pages: {}'.format(response['DocumentMetadata']['Pages'])) print('OUTPUT TO CSV FILE: ', output_file) # Display block information for block in blocks: DisplayBlockInfo(block) print() print() if 'NextToken' in response: paginationToken = response['NextToken'] else: finished = True def get_rows_columns_map(table_result, blocks_map): rows = {} for relationship in table_result['Relationships']: if relationship['Type'] == 'CHILD': for child_id in relationship['Ids']: try: cell = blocks_map[child_id] if cell['BlockType'] == 'CELL': row_index = cell['RowIndex'] col_index = cell['ColumnIndex'] if row_index not in rows: # create new row rows[row_index] = {} # get the text value rows[row_index][col_index] = get_text(cell, blocks_map) except KeyError: print("Error extracting Table data - {}:".format(KeyError)) pass return rows def get_text(result, blocks_map): text = '' if 'Relationships' in result: for relationship in result['Relationships']: if relationship['Type'] == 'CHILD': for child_id in relationship['Ids']: try: word = blocks_map[child_id] if word['BlockType'] == 'WORD': text += word['Text'] + ' ' if word['BlockType'] == 'SELECTION_ELEMENT': if word['SelectionStatus'] == 'SELECTED': text += 'X ' except KeyError: print("Error extracting Table data - {}:".format(KeyError)) return text def get_table_csv_results(blocks): pprint(blocks) blocks_map = {} table_blocks = [] for block in blocks: blocks_map[block['Id']] = block if block['BlockType'] == "TABLE": table_blocks.append(block) if len(table_blocks) <= 0: return " NO Table FOUND " csv = '' for index, table in enumerate(table_blocks): csv += generate_table_csv(table, blocks_map, index + 1) csv += '\n\n' return csv def generate_table_csv(table_result, blocks_map, table_index): rows = get_rows_columns_map(table_result, blocks_map) table_id = 'Table_' + str(table_index) # get cells. csv = 'Table: {0}\n\n'.format(table_id) for row_index, cols in rows.items(): for col_index, text in cols.items(): csv += '{}'.format(text) + "," csv += '\n' csv += '\n\n\n' return csv response_blocks = GetResults(jobId, file_name) ``` 1. Eseguire il codice. Dopo aver ottenuto i risultati, accertarsi di eliminare le risorse SNS e SQS associate oppure è possibile accumulare addebiti per loro. ------ # Creazione di unAWS LambdaFunzione Puoi chiamare le operazioni dell'API Amazon Textract da unAWS Lambdafunzione. Le seguenti istruzioni mostrano come creare una funzione Lambda in Python che chiama[DetectDocumentText](API_DetectDocumentText.md). restituisce un elenco di oggetti[Block](API_Block.md)oggetti. Per eseguire questo esempio, è necessario un bucket Amazon S3 che contenga un documento in formato PNG o JPEG. Per creare la funzione, utilizzare la console. Per un esempio che utilizza le funzioni Lambda per elaborare documenti su larga scala, vedere[Elaborazione di documenti su larga scala con Amazon Textract](https://github.com/aws-samples/amazon-textract-serverless-large-scale-document-processing). ## Per chiamare l'operazione DetectDocumentText da una funzione Lambda: **Fase 1: Creazione un pacchetto di distribuzione Lambda** 1. Aprire una finestra dei comandi. 1. Immettere i seguenti comandi per creare un pacchetto di distribuzione con la versione più recente dellaAWSSDK. ``` pip install boto3 --target python/. zip boto3-layer.zip -r python/ ``` **Fase 2: Creazione di una funzione Lambda** 1. Accedere alla Console di gestione AWS e aprire la console di AWS Lambda all’indirizzo [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/). 1. Scegli **Create function** (Crea funzione). 1. Specifica quanto segue. + Scegliere **Author from scratch** (Crea da zero). + Per **Function name (Nome funzione)** immettere un nome. + Per**Runtime**, scegli**Python 3.7**o**Python 3.6**. + Per**Scegliere o creare un ruolo di esecuzione**, scegli**Crea un nuovo ruolo con le autorizzazioni Lambda di base**. 1. Scegliere**Crea funzione**per creare la funzione Lambda. 1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). 1. Nel riquadro di navigazione, scegliere**Ruoli**. 1. Dall'elenco delle risorse scegli il ruolo IAM creato da Lambda. Il nome del ruolo inizia con il nome della funzione Lambda. 1. Seleziona**Autorizzazioni**tab, quindi scegli**Collegamento di policy**. 1. Seleziona le politiche di AmazonTextractFullAccess AmazonTextractFullAccess e Amazon S3. 1. Seleziona**collegamento di policy**. Per ulteriori informazioni, consulta[Creare una funzione Lambda con la console](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html) **Fase 3: Creazione e aggiunta di un livello** 1. Apri la console AWS Lambda all'indirizzo [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/). 1. Nel riquadro di navigazione scegli **Layers (Livelli)**. 1. Scegli **Create layer** (Crea livello). 1. Per**Nome**inserisci un nome. 1. In **Description (Descrizione)**, inserire una descrizione. 1. Per**Tipo di voce del codice**, scegli**Carica il file .zip**e selezionare**Caricamento**. 1. Nella finestra di dialogo, selezionare il file zip (boto3-layer.zip), lo zip creato in[Fase 1: Creazione un pacchetto di distribuzione Lambda](#create-deployment-package). 1. Per**Runtime compatibili**, scegli la versione del runtime in cui hai scelto[Fase 2: Creazione di una funzione Lambda](#create-function). 1. Scegliere**Create**per creare il livello. 1. Scegli l'icona del menu del riquadro di navigazione. 1. Nel riquadro di navigazione, seleziona **Funzioni**. 1. Nell'elenco delle risorse selezionare la funzione creata in[Fase 2: Creazione di una funzione Lambda](#create-function). 1. Scegliere**Configurazione**e nel**Designer**sezione, scegli**Livelli**(sotto il nome della funzione Lambda). 1. Nella**Livelli**sezione, scegli**Aggiunta di un livello**. 1. Scegliere**Seleziona dall'elenco di layer compatibili con il runtime**. 1. Nello stato**Strati compatibili**, selezionare il**Nome**e**Version**del livello creato nel passaggio 3. 1. Scegliere **Add** (Aggiungi). **Fase 4: Aggiungere codice Python alla funzione** 1. Nello stato**Designer**, scegliere la funzione. 1. Nell'editor del codice della funzione, aggiungere quanto segue al file**lambda\$1function.py**. Modificare i valori di`bucket`e`document`al tuo secchio e al tuo documento. ``` import json import boto3 def lambda_handler(event, context): bucket="bucket" document="document" client = boto3.client('textract') #process using S3 object response = client.detect_document_text( Document={'S3Object': {'Bucket': bucket, 'Name': document}}) #Get the text blocks blocks=response['Blocks'] return { 'statusCode': 200, 'body': json.dumps(blocks) } ``` 1. Scegliere**Save (Salva)**per salvare la funzione Lambda. **Fase 5: Test della funzione Lambda** 1. Seleziona**Test**. 1. Immettere un valore per**Event name (Nome evento):**. 1. Scegliere **Create** (Crea). 1. L'output, un elenco di[Block](API_Block.md)oggetti, vengono visualizzati nel riquadro dei risultati dell'esecuzione. Se il fileAWS Lambdafunzione restituisce un errore di timeout, potrebbe essere la causa una chiamata di operazione dell'API Amazon Textract. Per informazioni sull'estensione del periodo di timeout per unAWS Lambdafunzione, vedere[Configurazione funzione AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/resource-model.html). Per informazioni sull'invocazione di una funzione Lambda dal codice, vedere[RichiamoAWS LambdaFunzioni](https://docs.aws.amazon.com/lambda/latest/dg/invoking-lambda-functions.html). # Esempi di codice aggiuntivo La tabella seguente fornisce i collegamenti ad altri esempi di codice Amazon Textract. | Esempio | Descrizione | | --- | --- | | [Esempi di codice Amazon Textract](https://github.com/aws-samples/amazon-textract-code-samples) | Mostra vari modi in cui è possibile utilizzare Amazon Textract. | | [Elaborazione di documenti su larga scala con Amazon Textract](https://github.com/aws-samples/amazon-textract-serverless-large-scale-document-processing) | Mostra un'architettura di riferimento serverless che elabora i documenti su larga scala. | | [Amazon Textract Parser](https://github.com/aws-samples/amazon-textract-response-parser) | Mostra come analizzare il file[Block](API_Block.md)oggetti restituiti dalle operazioni di Amazon Textract. | | [Esempi di codice della documentazione di Amazon Textract](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/python/example_code/textract) | Esempi di codice utilizzati in questa guida. | | [Estrattore](https://github.com/aws-samples/amazon-textract-textractor) | Mostra come convertire l'output di Amazon Textract in più formati. | | [Genera documenti PDF ricercabili con Amazon Textract](https://github.com/aws-samples/amazon-textract-searchable-pdf) | Mostra come creare un documento PDF ricercabile da diversi tipi di documenti di input come immagini in formato JPG/PNG e documenti PDF scansionati. |