Guida introduttiva: Visione di Azure AI v3.2 - Lettura (disponibilità generale)

Articolo
10/16/2024

Edizioni OCR (Lettura)

Importante

Selezionare l'edizione Lettura più adatta alle proprie esigenze.

Input	Esempi	Edizione Lettura	Vantaggio
Immagini: generiche, in ambienti naturali	etichette, cartelli stradali e cartelloni	OCR per le immagini (versione 4.0)	Ottimizzato per immagini generiche non documentate con un'API sincrona a prestazioni avanzate che semplifica l'incorporamento di OCR negli scenari dell’esperienza utente.
Documenti: digitali e digitalizzato, incluse le immagini	libri, articoli e report	Modello di lettura di informazioni sui documenti	Ottimizzato per documenti contenenti molto testo, digitalizzati e digitali con un'API asincrona per automatizzare l'elaborazione intelligente dei documenti su larga scala.

Informazioni su Lettura di Visione di Azure AI v3.2 con disponibilità generale

Si sta cercando la versione più recente di Lettura di Visione di Azure AI v3.2 con disponibilità generale? Tutti i miglioramenti futuri di Lettura OCR fanno parte dei due servizi elencati in precedenza. Non sono previsti ulteriori aggiornamenti per Visione di Azure AI v3.2. Per altre informazioni, vedere Chiamare l'API di lettura per Visione di Azure AI 3.2 con disponibilità generale e Avvio rapido: Lettura di Visione di Azure AI v3.2 con disponibilità generale.

Introduzione all'API REST Lettura o alle librerie client di Visione di Azure AI. L'API Lettura fornisce algoritmi di intelligenza artificiale per estrarre il testo dalle immagini e restituirlo come stringhe strutturate. Seguire questi passaggi per installare un pacchetto nell'applicazione e provare il codice di esempio per le attività di base.

Utilizzare la libreria client di riconoscimento ottico dei caratteri (OCR) per leggere il testo stampato e scritto a mano da un'immagine. Il servizio OCR può leggere il testo visibile all’interno di un'immagine e convertirlo in un flusso di caratteri. Per ulteriori informazioni sul riconoscimento del testo, consultare Panoramica del riconoscimento ottico dei caratteri. Il codice in questa sezione usa il pacchetto più recente di Visione di Azure AI.

Suggerimento

È anche possibile estrarre il testo da un'immagine locale. Vedere i metodi ComputerVisionClient, ad esempio ReadInStreamAsync. In alternativa, per gli scenari con immagini locali, vedere il codice di esempio in GitHub.

Documentazione di riferimento | Codice sorgente della libreria | Pacchetto (NuGet) | Esempi

Prerequisiti

Una sottoscrizione di Azure: crearne una gratuitamente.
IDE di Visual Studio o la versione corrente di .NET Core.
Una risorsa Visione di Azure AI. È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.
Saranno necessari la chiave e l'endpoint della risorsa creata per connettere l'applicazione al servizio Visione di Azure AI.
1. Dopo la distribuzione della risorsa Visione di Azure AI, fare clic su Vai alla risorsa.
2. Nel menu di spostamento a sinistra selezionare Chiavi ed Endpoint.
3. Copiare una delle chiavi e l'endpoint da usare più avanti in questo articolo.

Creare variabili di ambiente

In questo esempio, vengono scritte le credenziali nelle variabili di ambiente del computer locale che esegue l'applicazione.

Vai al portale di Azure. Se la risorsa creata nella sezione Prerequisiti è stata distribuita correttamente, selezionare Vai alla risorsa in Passaggi successivi. La chiave e l'endpoint saranno disponibili nella pagina Chiavi ed endpoint in Gestione risorse. La chiave della risorsa non corrisponde all'ID sottoscrizione di Azure.

Per impostare la variabile di ambiente per la chiave e l'endpoint, aprire una finestra della console e seguire le istruzioni del sistema operativo e dell'ambiente di sviluppo.

Per impostare la VISION_KEYvariabile di ambiente, sostituire <your_key> con una delle chiavi della risorsa.
Per impostare la VISION_ENDPOINTvariabile di ambiente, sostituire <your_endpoint> con l'endpoint della risorsa.

Importante

Se si usa una chiave API, archiviarla in modo sicuro in un'altra posizione, ad esempio in Azure Key Vault. Non includere la chiave API direttamente nel codice e non esporla mai pubblicamente.

Per altre informazioni sulla sicurezza dei servizi IA, vedere Autenticare richieste in Servizi di Azure AI.

Windows
Linux

setx VISION_KEY <your_key>

setx VISION_ENDPOINT <your_endpoint>

Dopo aver aggiunto le variabili di ambiente, potrebbe essere necessario riavviare gli eventuali programmi in esecuzione che leggeranno le variabili di ambiente, inclusa la finestra della console.

export VISION_KEY=<your_key>

export VISION_ENDPOINT=<your_endpoint>

Dopo avere aggiunto le variabili di ambiente, eseguire source ~/.bashrc dalla finestra della console per rendere effettive le modifiche.

Leggere il testo stampato e scritto a mano

Creare una nuova applicazione C#.
- IDE di Visual Studio
- CLI
Usando Visual Studio, creare un progetto App console (.NET Framework) per C#, Windows, Console.

Dopo aver creato un nuovo progetto, installare la libreria client:
1. Fare clic con il pulsante destro del mouse sulla soluzione del progetto nel riquadro Esplora soluzioni e selezionare Gestisci pacchetti NuGet per la soluzione.
2. Nella finestra di dialogo Gestione pacchetti visualizzata selezionare Sfoglia. Selezionare Includi versione preliminare.
3. Cercare e selezionare Microsoft.Azure.CognitiveServices.Vision.ComputerVision.
4. Nella finestra di dialogo dei dettagli selezionare il progetto e selezionare la versione stabile più recente. Quindi selezionare Installa.
1. In una finestra di una console usare il comando dotnet new per creare una nuova app console denominata computer-vision-quickstart.
```
dotnet new console -n computer-vision-quickstart
```
  Questo comando crea un semplice progetto C# "Hello World" con un unico file di origine: Program.cs.
2. Passare alla cartella dell'app appena creata e quindi compilare l'applicazione:
```
dotnet build
```
  L'output di compilazione non deve contenere alcun avviso o errore.
```
...
Build succeeded.
 0 Warning(s)
 0 Error(s)
...
```
3. Nella directory dell'applicazione installare la libreria client di Visione di Azure AI per .NET tramite il comando seguente:
```
dotnet add package Microsoft.Azure.CognitiveServices.Vision.ComputerVision --version 7.0.0
```

Dalla directory del progetto aprire il file Program.cs nell'ambiente di sviluppo integrato o nell'editor preferito. Sostituire il contenuto di Program.cs con il codice seguente.

using System;
using System.Collections.Generic;
using Microsoft.Azure.CognitiveServices.Vision.ComputerVision;
using Microsoft.Azure.CognitiveServices.Vision.ComputerVision.Models;
using System.Threading.Tasks;
using System.IO;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.Threading;
using System.Linq;

namespace ComputerVisionQuickstart
{
    class Program
    {
        // Add your Computer Vision key and endpoint
        static string key = Environment.GetEnvironmentVariable("VISION_KEY");
        static string endpoint = Environment.GetEnvironmentVariable("VISION_ENDPOINT");

        private const string READ_TEXT_URL_IMAGE = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/printed_text.jpg";

        static void Main(string[] args)
        {
            Console.WriteLine("Azure Cognitive Services Computer Vision - .NET quickstart example");
            Console.WriteLine();

            ComputerVisionClient client = Authenticate(endpoint, key);

            // Extract text (OCR) from a URL image using the Read API
            ReadFileUrl(client, READ_TEXT_URL_IMAGE).Wait();
        }

        public static ComputerVisionClient Authenticate(string endpoint, string key)
        {
            ComputerVisionClient client =
              new ComputerVisionClient(new ApiKeyServiceClientCredentials(key))
              { Endpoint = endpoint };
            return client;
        }

        public static async Task ReadFileUrl(ComputerVisionClient client, string urlFile)
        {
            Console.WriteLine("----------------------------------------------------------");
            Console.WriteLine("READ FILE FROM URL");
            Console.WriteLine();

            // Read text from URL
            var textHeaders = await client.ReadAsync(urlFile);
            // After the request, get the operation location (operation ID)
            string operationLocation = textHeaders.OperationLocation;
            Thread.Sleep(2000);

            // Retrieve the URI where the extracted text will be stored from the Operation-Location header.
            // We only need the ID and not the full URL
            const int numberOfCharsInOperationId = 36;
            string operationId = operationLocation.Substring(operationLocation.Length - numberOfCharsInOperationId);

            // Extract the text
            ReadOperationResult results;
            Console.WriteLine($"Extracting text from URL file {Path.GetFileName(urlFile)}...");
            Console.WriteLine();
            do
            {
                results = await client.GetReadResultAsync(Guid.Parse(operationId));
            }
            while ((results.Status == OperationStatusCodes.Running ||
                results.Status == OperationStatusCodes.NotStarted));

            // Display the found text.
            Console.WriteLine();
            var textUrlFileResults = results.AnalyzeResult.ReadResults;
            foreach (ReadResult page in textUrlFileResults)
            {
                foreach (Line line in page.Lines)
                {
                    Console.WriteLine(line.Text);
                }
            }
            Console.WriteLine();
        }

    }
}

Come passaggio facoltativo, vedere Determinare come elaborare i dati. Ad esempio, per specificare in modo esplicito il modello di disponibilità generale più recente, modificare la chiamata ReadAsync come illustrato. Ignorare il parametro o usare "latest" per usare il modello di disponibilità generale più recente.
```
  // Read text from URL with a specific model version
  var textHeaders = await client.ReadAsync(urlFile,null,null,"2022-04-30");
```
Eseguire l'applicazione.
- IDE di Visual Studio
- CLI
- Scegliere Avvia debug dal menu Debug.
- Utilizzare il comando dotnet run nella directory del progetto.
```
dotnet run
```

Output

Azure AI Vision - .NET quickstart example

----------------------------------------------------------
READ FILE FROM URL

Extracting text from URL file printed_text.jpg...


Nutrition Facts Amount Per Serving
Serving size: 1 bar (40g)
Serving Per Package: 4
Total Fat 13g
Saturated Fat 1.5g
Amount Per Serving
Trans Fat 0g
Calories 190
Cholesterol 0mg
ories from Fat 110
Sodium 20mg
nt Daily Values are based on Vitamin A 50%
calorie diet.

Pulire le risorse

Se si vuole pulire e rimuovere una sottoscrizione a Servizi di Azure AI, è possibile eliminare la risorsa o il gruppo di risorse. L'eliminazione del gruppo di risorse comporta anche l'eliminazione di tutte le altre risorse associate.

Passaggi successivi

Grazie a questa guida di avvio rapido è stato possibile apprendere come installare la libreria client OCR e usare l'API Lettura. In seguito, sarà possibile apprendere altre informazioni sulle funzionalità dell'API Lettura.

Chiamare l'API Lettura

Panoramica di OCR
Il codice sorgente per questo esempio è disponibile su GitHub.

Utilizzare la libreria client di riconoscimento ottico dei caratteri (OCR) per leggere il testo stampato e scritto a mano da un'immagine remota. Il servizio OCR può leggere il testo visibile all’interno di un'immagine e convertirlo in un flusso di caratteri. Per ulteriori informazioni sul riconoscimento del testo, consultare Panoramica del riconoscimento ottico dei caratteri.

Suggerimento

È anche possibile leggere il testo da un'immagine locale. Vedere i metodi ComputerVisionClientOperationsMixin, ad esempio read_in_stream. In alternativa, per gli scenari con immagini locali, vedere il codice di esempio in GitHub.

Documentazione di riferimento | Codice sorgente della libreria | Pacchetto (PiPy) | Esempi

Prerequisiti

Una sottoscrizione di Azure: crearne una gratuitamente.
Python 3.x.
L'installazione di Python deve includere pip. È possibile verificare se pip è installato eseguendo pip --version nella riga di comando. Per ottenere pip, installare la versione più recente di Python.
Una risorsa Visione di Azure AI. È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.
Saranno necessari la chiave e l'endpoint della risorsa creata per connettere l'applicazione al servizio Visione di Azure AI.
1. Dopo la distribuzione della risorsa Visione di Azure AI, fare clic su Vai alla risorsa.
2. Nel menu di spostamento a sinistra selezionare Chiavi ed Endpoint.
3. Copiare una delle chiavi e l'endpoint da usare più avanti in questo articolo.

Creare variabili di ambiente

In questo esempio, vengono scritte le credenziali nelle variabili di ambiente del computer locale che esegue l'applicazione.

Per impostare la variabile di ambiente per la chiave e l'endpoint, aprire una finestra della console e seguire le istruzioni del sistema operativo e dell'ambiente di sviluppo.

Per impostare la VISION_KEYvariabile di ambiente, sostituire <your_key> con una delle chiavi della risorsa.
Per impostare la VISION_ENDPOINTvariabile di ambiente, sostituire <your_endpoint> con l'endpoint della risorsa.

Importante

Se si usa una chiave API, archiviarla in modo sicuro in un'altra posizione, ad esempio in Azure Key Vault. Non includere la chiave API direttamente nel codice e non esporla mai pubblicamente.

Per altre informazioni sulla sicurezza dei servizi IA, vedere Autenticare richieste in Servizi di Azure AI.

Windows
Linux

setx VISION_KEY <your_key>

setx VISION_ENDPOINT <your_endpoint>

Dopo aver aggiunto le variabili di ambiente, potrebbe essere necessario riavviare gli eventuali programmi in esecuzione che leggeranno le variabili di ambiente, inclusa la finestra della console.

export VISION_KEY=<your_key>

export VISION_ENDPOINT=<your_endpoint>

Dopo avere aggiunto le variabili di ambiente, eseguire source ~/.bashrc dalla finestra della console per rendere effettive le modifiche.

Leggere il testo stampato e scritto a mano

Installare la libreria client.

In una finestra della console eseguire il comando seguente:
```
pip install --upgrade azure-cognitiveservices-vision-computervision
```
Installare la libreria Pillow.
```
pip install pillow
```
Creare un nuovo file dell'applicazione Python quickstart-file.py. Quindi, aprirlo nell'editor o nell'IDE preferito.

Sostituire il contenuto di quickstart-file.py con il codice seguente.

from azure.cognitiveservices.vision.computervision import ComputerVisionClient
from azure.cognitiveservices.vision.computervision.models import OperationStatusCodes
from azure.cognitiveservices.vision.computervision.models import VisualFeatureTypes
from msrest.authentication import CognitiveServicesCredentials

from array import array
import os
from PIL import Image
import sys
import time

'''
Authenticate
Authenticates your credentials and creates a client.
'''
subscription_key = os.environ["VISION_KEY"]
endpoint = os.environ["VISION_ENDPOINT"]

computervision_client = ComputerVisionClient(endpoint, CognitiveServicesCredentials(subscription_key))
'''
END - Authenticate
'''

'''
OCR: Read File using the Read API, extract text - remote
This example will extract text in an image, then print results, line by line.
This API call can also extract handwriting style text (not shown).
'''
print("===== Read File - remote =====")
# Get an image with text
read_image_url = "https://learn.microsoft.com/azure/ai-services/computer-vision/media/quickstarts/presentation.png"

# Call API with URL and raw response (allows you to get the operation location)
read_response = computervision_client.read(read_image_url,  raw=True)

# Get the operation location (URL with an ID at the end) from the response
read_operation_location = read_response.headers["Operation-Location"]
# Grab the ID from the URL
operation_id = read_operation_location.split("/")[-1]

# Call the "GET" API and wait for it to retrieve the results 
while True:
    read_result = computervision_client.get_read_result(operation_id)
    if read_result.status not in ['notStarted', 'running']:
        break
    time.sleep(1)

# Print the detected text, line by line
if read_result.status == OperationStatusCodes.succeeded:
    for text_result in read_result.analyze_result.read_results:
        for line in text_result.lines:
            print(line.text)
            print(line.bounding_box)
print()
'''
END - Read File - remote
'''

print("End of Computer Vision quickstart.")

Come passaggio facoltativo, vedere Determinare come elaborare i dati. Ad esempio, per specificare in modo esplicito il modello di disponibilità generale più recente, modificare l'istruzione read come illustrato. Se si ignora il parametro o si usa "latest" viene usato automaticamente il modello di disponibilità generale più recente.
```
   # Call API with URL and raw response (allows you to get the operation location)
   read_response = computervision_client.read(read_image_url,  raw=True, model_version="2022-04-30")
```
Eseguire l'applicazione con il comando python nel file quickstart.
```
python quickstart-file.py
```

Output

===== Read File - remote =====
The quick brown fox jumps
[38.0, 650.0, 2572.0, 699.0, 2570.0, 854.0, 37.0, 815.0]
Over
[184.0, 1053.0, 508.0, 1044.0, 510.0, 1123.0, 184.0, 1128.0]
the lazy dog!
[639.0, 1011.0, 1976.0, 1026.0, 1974.0, 1158.0, 637.0, 1141.0]

End of Azure AI Vision quickstart.

Pulire le risorse

Passaggi successivi

Chiamare l'API Lettura

Panoramica di OCR
Il codice sorgente per questo esempio è disponibile su GitHub.

Utilizzare la libreria client di riconoscimento ottico dei caratteri (OCR) per leggere il testo stampato e scritto a mano con l'API Lettura. Il servizio OCR può leggere il testo visibile all’interno di un'immagine e convertirlo in un flusso di caratteri. Per ulteriori informazioni sul riconoscimento del testo, consultare Panoramica del riconoscimento ottico dei caratteri.

Suggerimento

È anche possibile leggere il testo da un'immagine locale. Vedere i metodi ComputerVisionClient, ad esempio readInStream. In alternativa, per gli scenari con immagini locali, vedere il codice di esempio in GitHub.

Documentazione di riferimento | Pacchetto (npm) | Esempi

Prerequisiti

Una sottoscrizione di Azure: crearne una gratuitamente.
Versione corrente di Node.js.
Una risorsa Visione di Azure AI. È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.
Saranno necessari la chiave e l'endpoint della risorsa creata per connettere l'applicazione al servizio Visione di Azure AI.
1. Dopo la distribuzione della risorsa Visione di Azure AI, fare clic su Vai alla risorsa.
2. Nel menu di spostamento a sinistra selezionare Chiavi ed Endpoint.
3. Copiare una delle chiavi e l'endpoint da usare più avanti in questo articolo.

Creare variabili di ambiente

In questo esempio, vengono scritte le credenziali nelle variabili di ambiente del computer locale che esegue l'applicazione.

Per impostare la variabile di ambiente per la chiave e l'endpoint, aprire una finestra della console e seguire le istruzioni del sistema operativo e dell'ambiente di sviluppo.

Per impostare la VISION_KEYvariabile di ambiente, sostituire <your_key> con una delle chiavi della risorsa.
Per impostare la VISION_ENDPOINTvariabile di ambiente, sostituire <your_endpoint> con l'endpoint della risorsa.

Importante

Se si usa una chiave API, archiviarla in modo sicuro in un'altra posizione, ad esempio in Azure Key Vault. Non includere la chiave API direttamente nel codice e non esporla mai pubblicamente.

Per altre informazioni sulla sicurezza dei servizi IA, vedere Autenticare richieste in Servizi di Azure AI.

Windows
Linux

setx VISION_KEY <your_key>

setx VISION_ENDPOINT <your_endpoint>

Dopo aver aggiunto le variabili di ambiente, potrebbe essere necessario riavviare gli eventuali programmi in esecuzione che leggeranno le variabili di ambiente, inclusa la finestra della console.

export VISION_KEY=<your_key>

export VISION_ENDPOINT=<your_endpoint>

Dopo avere aggiunto le variabili di ambiente, eseguire source ~/.bashrc dalla finestra della console per rendere effettive le modifiche.

Leggere il testo stampato e scritto a mano

Creare una nuova applicazione Node.js.

In una finestra console creare una nuova directory per l'app e passare ad essa.
```
mkdir myapp
cd myapp
```
Eseguire il comando npm init per creare un'applicazione Node con un file package.json. Selezionare Invio per qualsiasi prompt.
```
npm init
```
Per installare la libreria client, installare il pacchetto npm ms-rest-azure e @azure/cognitiveservices-computervision:
```
npm install ms-rest-azure
npm install @azure/cognitiveservices-computervision
```
Installare il modulo asincrono:
```
npm install async
```
Il file package.json dell'app viene aggiornato con le dipendenze.
Creare un nuovo file, index.js, e aprirlo in un editor di testo.

Incollare il codice seguente infile index.js.

'use strict';

const async = require('async');
const fs = require('fs');
const https = require('https');
const path = require("path");
const createReadStream = require('fs').createReadStream
const sleep = require('util').promisify(setTimeout);
const ComputerVisionClient = require('@azure/cognitiveservices-computervision').ComputerVisionClient;
const ApiKeyCredentials = require('@azure/ms-rest-js').ApiKeyCredentials;
/**
 * AUTHENTICATE
 * This single client is used for all examples.
 */
const key = process.env.VISION_KEY;
const endpoint = process.env.VISION_ENDPOINT;

const computerVisionClient = new ComputerVisionClient(
  new ApiKeyCredentials({ inHeader: { 'Ocp-Apim-Subscription-Key': key } }), endpoint);
/**
 * END - Authenticate
 */

function computerVision() {
  async.series([
    async function () {

      /**
       * OCR: READ PRINTED & HANDWRITTEN TEXT WITH THE READ API
       * Extracts text from images using OCR (optical character recognition).
       */
      console.log('-------------------------------------------------');
      console.log('READ PRINTED, HANDWRITTEN TEXT AND PDF');
      console.log();

      // URL images containing printed and/or handwritten text. 
      // The URL can point to image files (.jpg/.png/.bmp) or multi-page files (.pdf, .tiff).
      const printedTextSampleURL = 'https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/printed_text.jpg';

      // Recognize text in printed image from a URL
      console.log('Read printed text from URL...', printedTextSampleURL.split('/').pop());
      const printedResult = await readTextFromURL(computerVisionClient, printedTextSampleURL);
      printRecText(printedResult);

      // Perform read and await the result from URL
      async function readTextFromURL(client, url) {
        // To recognize text in a local image, replace client.read() with readTextInStream() as shown:
        let result = await client.read(url);
        // Operation ID is last path segment of operationLocation (a URL)
        let operation = result.operationLocation.split('/').slice(-1)[0];

        // Wait for read recognition to complete
        // result.status is initially undefined, since it's the result of read
        while (result.status !== "succeeded") { await sleep(1000); result = await client.getReadResult(operation); }
        return result.analyzeResult.readResults; // Return the first page of result. Replace [0] with the desired page if this is a multi-page file such as .pdf or .tiff.
      }

      // Prints all text from Read result
      function printRecText(readResults) {
        console.log('Recognized text:');
        for (const page in readResults) {
          if (readResults.length > 1) {
            console.log(`==== Page: ${page}`);
          }
          const result = readResults[page];
          if (result.lines.length) {
            for (const line of result.lines) {
              console.log(line.words.map(w => w.text).join(' '));
            }
          }
          else { console.log('No recognized text.'); }
        }
      }

      /**
       * 
       * Download the specified file in the URL to the current local folder
       * 
       */
      function downloadFilesToLocal(url, localFileName) {
        return new Promise((resolve, reject) => {
          console.log('--- Downloading file to local directory from: ' + url);
          const request = https.request(url, (res) => {
            if (res.statusCode !== 200) {
              console.log(`Download sample file failed. Status code: ${res.statusCode}, Message: ${res.statusMessage}`);
              reject();
            }
            var data = [];
            res.on('data', (chunk) => {
              data.push(chunk);
            });
            res.on('end', () => {
              console.log('   ... Downloaded successfully');
              fs.writeFileSync(localFileName, Buffer.concat(data));
              resolve();
            });
          });
          request.on('error', function (e) {
            console.log(e.message);
            reject();
          });
          request.end();
        });
      }

      /**
       * END - Recognize Printed & Handwritten Text
       */
      console.log();
      console.log('-------------------------------------------------');
      console.log('End of quickstart.');

    },
    function () {
      return new Promise((resolve) => {
        resolve();
      })
    }
  ], (err) => {
    throw (err);
  });
}

computerVision();

Come passaggio facoltativo, vedere Determinare come elaborare i dati. Ad esempio, per specificare in modo esplicito il modello di disponibilità generale più recente, modificare l'istruzione read come illustrato. Se si ignora il parametro o si usa "latest" viene usato automaticamente il modello di disponibilità generale più recente.
```
  let result = await client.read(url,{modelVersion:"2022-04-30"});
```
Eseguire l'applicazione con il comando node nel file quickstart.
```
node index.js
```

Output

-------------------------------------------------
READ PRINTED, HANDWRITTEN TEXT AND PDF

Read printed text from URL... printed_text.jpg
Recognized text:
Nutrition Facts Amount Per Serving
Serving size: 1 bar (40g)
Serving Per Package: 4
Total Fat 13g
Saturated Fat 1.5g
Amount Per Serving
Trans Fat 0g
Calories 190
Cholesterol 0mg
ories from Fat 110
Sodium 20mg
nt Daily Values are based on Vitamin A 50%
calorie diet.

-------------------------------------------------
End of quickstart.

Pulire le risorse

Passaggi successivi

Chiamare l'API Lettura

Panoramica di OCR
Il codice sorgente per questo esempio è disponibile su GitHub.

Utilizzare l'API REST di riconoscimento ottico dei caratteri (OCR) per leggere il testo stampato e scritto a mano.

Nota

Questa guida di avvio rapido usa comandi cURL per chiamare l'API REST. È anche possibile chiamare l'API REST usando un linguaggio di programmazione. Vedere gli esempi di GitHub per esempi in C#, Python, Java e JavaScript.

Prerequisiti

Una sottoscrizione di Azure: crearne una gratuitamente.
cURL installato.
Una risorsa Visione di Azure AI. È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.
Saranno necessari la chiave e l'endpoint della risorsa creata per connettere l'applicazione al servizio Visione di Azure AI.
1. Dopo la distribuzione della risorsa Visione di Azure AI, fare clic su Vai alla risorsa.
2. Nel menu di spostamento a sinistra selezionare Chiavi ed Endpoint.
3. Copiare una delle chiavi e l'endpoint da usare più avanti in questo articolo.

Leggere il testo stampato e scritto a mano

Il servizio di riconoscimento ottico dei caratteri (OCR) può estrarre il testo visibile in un'immagine o in un documento e convertirlo in un flusso di caratteri. Per ulteriori informazioni sull'estrazione del testo, consultare Panoramica del riconoscimento ottico dei caratteri.

Chiamare l'API di lettura

Per creare ed eseguire l'esempio, seguire questa procedura:

Copiare il comando seguente in un editor di testo.
Apportare le modifiche seguenti al comando, dove necessario:
1. Sostituire il valore di <key> con la propria chiave.
2. Sostituire la prima parte dell'URL della richiesta (https://westcentralus.api.cognitive.microsoft.com/) con il testo dell'URL dell'endpoint.
  
  Nota
  
  Le nuove risorse create dopo il 1° luglio 2019 useranno nomi di sottodomini personalizzati. Per altre informazioni e per un elenco completo degli endpoint a livello di area, vedere Nomi di sottodomini personalizzati per Servizi di Azure AI.
3. Facoltativamente, modificare l'URL dell'immagine nel corpo della richiesta (https://learn.microsoft.com/azure/ai-services/computer-vision/media/quickstarts/presentation.png) nell'URL di un'altra immagine da analizzare.
Aprire una finestra del prompt dei comandi.
Incollare il comando dall'editor di testo nella finestra del prompt dei comandi e quindi eseguire il comando.

curl -v -X POST "https://westcentralus.api.cognitive.microsoft.com/vision/v3.2/read/analyze" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: <subscription key>" --data-ascii "{'url':'https://learn.microsoft.com/azure/ai-services/computer-vision/media/quickstarts/presentation.png'}"

La risposta include un'intestazione Operation-Location, il cui valore è un URL univoco. Usare questo URL per eseguire query sui risultati dell'operazione di lettura. L'URL scade dopo 48 ore.

Specificare la versione del modello (facoltativo)

Come passaggio facoltativo, vedere Determinare come elaborare i dati. Ad esempio, per specificare in modo esplicito il modello di disponibilità generale più recente, utilizzare model-version=2022-04-30 come parametro. Se si ignora il parametro o si usa model-version=latest viene usato automaticamente il modello di disponibilità generale più recente.

curl -v -X POST "https://westcentralus.api.cognitive.microsoft.com/vision/v3.2/read/analyze?model-version=2022-04-30" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: <subscription key>" --data-ascii "{'url':'https://learn.microsoft.com/azure/ai-services/computer-vision/media/quickstarts/presentation.png'}"

Ottenere risultati della lettura

Copiare il comando seguente in un editor di testo.
Sostituire l'URL con il valore Operation-Location copiato nella procedura precedente.
Sostituire il valore di <key> con la propria chiave.
Aprire una finestra della console.

Incollare il comando dall'editor di testo nella finestra della console e quindi eseguire il comando.

curl -v -X GET "https://westcentralus.api.cognitive.microsoft.com/vision/v3.2/read/analyzeResults/{operationId}" -H "Ocp-Apim-Subscription-Key: {key}" --data-ascii "{body}"

Esaminare i risultati

Una risposta con esito positivo viene restituita in JSON. L'applicazione di esempio analizza e visualizza una risposta con esito positivo nella finestra della console, come nell'esempio seguente:

{
  "status": "succeeded",
  "createdDateTime": "2021-04-08T21:56:17.6819115+00:00",
  "lastUpdatedDateTime": "2021-04-08T21:56:18.4161316+00:00",
  "analyzeResult": {
    "version": "3.2",
    "readResults": [
      {
        "page": 1,
        "angle": 0,
        "width": 338,
        "height": 479,
        "unit": "pixel",
        "lines": [
          {
            "boundingBox": [
              25,
              14,
              318,
              14,
              318,
              59,
              25,
              59
            ],
            "text": "NOTHING",
            "appearance": {
              "style": {
                "name": "other",
                "confidence": 0.971
              }
            },
            "words": [
              {
                "boundingBox": [
                  27,
                  15,
                  294,
                  15,
                  294,
                  60,
                  27,
                  60
                ],
                "text": "NOTHING",
                "confidence": 0.994
              }
            ]
          }
        ]
      }
    ]
  }
}

Pulire le risorse

Passaggi successivi

Grazie a questa guida di avvio rapido è stato possibile apprendere come richiamare l'API REST Lettura. In seguito, sarà possibile apprendere altre informazioni sulle funzionalità dell'API Lettura.

Chiamare l'API Lettura

Panoramica di OCR

Prerequisiti

Una sottoscrizione di Azure: crearne una gratuitamente.
Una risorsa Visione di Azure AI. È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.
Connettersi a Vision Studio.
- Potrebbe essere necessario eseguire l'accesso.
- Dopo aver eseguito l'accesso, selezionare Visualizza tutte le risorse. Se necessario, fare clic su Aggiorna. Verificare che la risorsa sia disponibile.
Per altre informazioni, vedere Introduzione all'uso di Vision Studio.

Leggere il testo stampato e scritto a mano

In Riconoscimento ottico dei caratteri selezionare Estrai testo dalle immagini.
In Prova, confermare che questa demo comporta l'utilizzo dell'account Azure. Per altre informazioni, vedere Prezzi di Visione di Azure AI.
Selezionare un'immagine dal set disponibile o caricarne una a propria scelta.
Se necessario, scegliere Selezionare una risorsa per selezionare la risorsa.

Dopo aver selezionato l'immagine, il testo estratto viene visualizzato nella finestra di output. È anche possibile selezionare la scheda JSON per visualizzare l'output JSON restituito dalla chiamata API.

Sotto all’esperienza try-it-out sono riportati i passaggi successivi per iniziare a utilizzare questa funzionalità nella propria applicazione.

Passaggi successivi

In questa guida di avvio rapido è stato illustrato l’uso di Vision Studio per accedere all'API Lettura. In seguito, sarà possibile apprendere altre informazioni sulle funzionalità dell'API Lettura.

Chiamare l'API Lettura

Panoramica di OCR

Condividi tramite

Guida introduttiva: Visione di Azure AI v3.2 - Lettura (disponibilità generale)

Edizioni OCR (Lettura)

Prerequisiti

Creare variabili di ambiente

Leggere il testo stampato e scritto a mano

Output

Pulire le risorse

Passaggi successivi

Prerequisiti

Creare variabili di ambiente

Leggere il testo stampato e scritto a mano

Output

Pulire le risorse

Passaggi successivi

Prerequisiti

Creare variabili di ambiente

Leggere il testo stampato e scritto a mano

Output

Pulire le risorse

Passaggi successivi

Prerequisiti

Leggere il testo stampato e scritto a mano

Chiamare l'API di lettura

Specificare la versione del modello (facoltativo)

Ottenere risultati della lettura

Esaminare i risultati

Pulire le risorse

Passaggi successivi

Prerequisiti

Leggere il testo stampato e scritto a mano

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive