Avvio rapido: Riconoscere l'input penna con l'API REST Riconoscimento input penna e Java

Articolo
08/24/2020

Nota

L'anteprima dell'API riconoscimento input penna è terminata il 26 agosto 2020. Se esistono risorse di riconoscimento input penna, è possibile continuare a usarle fino a quando il servizio non verrà ritirato completamente il 31 gennaio 2021.

Usare questa guida di avvio rapido per iniziare a usare l'API Riconoscimento input penna su tratti input penna. Questa applicazione Java invia una richiesta API contenenti i dati del tratto input penna in formato JSON e riceve la risposta.

L'applicazione è scritta in Java, ma l'API è un servizio Web RESTful compatibile con la maggior parte dei linguaggi di programmazione.

In genere è necessario chiamare l'API da un'app di input penna. Questa guida di avvio rapido invia i dati del tratto input penna per l'esempio scritto a mano seguente da un file JSON.

immagine di testo scritto a mano

Il codice sorgente per questo avvio rapido è disponibile su GitHub.

Prerequisiti

Java™ Development Kit(JDK) 7 o versione successiva.
Importare queste librerie dal repository Maven
- Pacchetto JSON in Java
- Pacchetto Apache HttpClient
I dati di esempio del tratto input penna per questo avvio rapido sono disponibili in GitHub.

Creare una risorsa di riconoscimento input penna

Nota

Gli endpoint per le risorse create dopo il 1° luglio 2019 usano il formato di sottodominio personalizzato riportato di seguito. Per altre informazioni e per un elenco completo degli endpoint a livello di area, vedere Nomi di sottodomini personalizzati per Servizi cognitivi.

I Servizi cognitivi di Azure sono rappresentati dalle risorse di Azure a cui si effettua la sottoscrizione. Creare una risorsa per il riconoscimento input penna usando il portale Azure.

Dopo aver creato una risorsa, ottenere l'endpoint e il codice aprendo la risorsa nel portale di Azure e facendo clic su Avvio rapido.

Creare due variabili di ambiente:

INK_RECOGNITION_SUBSCRIPTION_KEY: la chiave di sottoscrizione per l'autenticazione delle richieste.
INK_RECOGNITION_ENDPOINT: l'endpoint per la risorsa. L'aspetto sarà simile al seguente:
https://<your-custom-subdomain>.api.cognitive.microsoft.com

Creare una nuova applicazione

Creare un nuovo progetto Java nell'ambiente di sviluppo integrato o nell'editor preferito e importare le librerie seguenti.

import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;

Creare variabili per la chiave di sottoscrizione, l'endpoint e il file JSON. L'endpoint verrà poi aggiunto all'URI del riconoscimento input penna.

// Add your Azure Ink Recognition subscription key to your environment variables.
private static final String subscriptionKey = System.getenv("INK_RECOGNITION_SUBSCRIPTION_KEY");

// Add your Azure Ink Recognition endpoint to your environment variables.
public static final String rootUrl = System.getenv("INK_RECOGNITION_ENDPOINT");
public static final String inkRecognitionUrl = "/inkrecognizer/v1.0-preview/recognize";
// Replace the dataPath string with a path to the JSON formatted ink stroke data file.
private static final String dataPath = "PATH_TO_INK_STROKE_DATA";

Creare una funzione per inviare richieste

Creare una nuova funzione denominata sendRequest() che accetta le variabili create in precedenza. Quindi, eseguire i passaggi seguenti.
Creare un oggetto CloseableHttpClient che può inviare richieste all'API. Inviare la richiesta a un oggetto richiesta HttpPut combinando l'endpoint e l'URL di riconoscimento input penna.
Usare la funzione setHeader() della richiesta per impostare l'intestazione Content-Type su application/json e aggiungere la chiave di sottoscrizione all'intestazione Ocp-Apim-Subscription-Key.
Usare la funzione setEntity() della richiesta per i dati da inviare.
Usare la funzione execute() del client per inviare la richiesta e salvarla in un oggetto CloseableHttpResponse.

Creare un oggetto HttpEntity in cui archiviare il contenuto della risposta. Ottenere il contenuto con getEntity(). Viene restituita la risposta se non è vuota.

static String sendRequest(String endpoint, String apiAddress, String subscriptionKey, String requestData) {
    try (CloseableHttpClient client = HttpClients.createDefault()) {
        HttpPut request = new HttpPut(endpoint + apiAddress);
        // Request headers.
        request.setHeader("Content-Type", "application/json");
        request.setHeader("Ocp-Apim-Subscription-Key", subscriptionKey);
        request.setEntity(new StringEntity(requestData));
        try (CloseableHttpResponse response = client.execute(request)) {
            HttpEntity respEntity = response.getEntity();
            if (respEntity != null) {
                return EntityUtils.toString(respEntity, "utf-8");
            }
        } catch (Exception respEx) {
            respEx.printStackTrace();
        }
    } catch (IOException ex) {
        System.err.println("Exception on Anomaly Detector: " + ex.getMessage());
        ex.printStackTrace();
    }
    return null;
}

Inviare una richiesta di riconoscimento input penna

Creare un metodo denominato recognizeInk() per riconoscere i dati dell'input penna. Chiamare il metodo sendRequest() creato in precedenza con l'endpoint, l'URL, la chiave di sottoscrizione e i dati json. Ottenere il risultato e visualizzarlo nella console.

static void recognizeInk(String requestData) {
    System.out.println("Sending an Ink recognition request.");

    String result = sendRequest(rootUrl, inkRecognitionUrl, subscriptionKey, requestData);
    
    // Pretty-print the JSON result
    try {
        ObjectMapper objectMapper = new ObjectMapper();
        Map<String, Object> response = objectMapper.readValue(result, HashMap.class);
        System.out.println(objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(response));
    } catch (JsonParseException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }  
}

Caricare i dati dell'input penna e inviare la richiesta

Nel metodo main dell'applicazione leggere il file JSON che contiene i dati che verranno aggiunti alle richieste.

Chiamare la funzione di riconoscimento input penna creata in precedenza.

public static void main(String[] args) throws Exception {

    String requestData = new String(Files.readAllBytes(Paths.get(dataPath)), "utf-8");
    recognizeInk(requestData);
}

Eseguire l'applicazione e visualizzare la risposta

Eseguire l'applicazione. Viene restituita una risposta con esito positivo in formato JSON. È anche possibile trovare la risposta JSON in GitHub.

Passaggi successivi

Informazioni di riferimento sulle API REST

Per vedere come funziona l'API Riconoscimento input penna in un'app di input penna, esaminare le applicazioni di esempio seguenti in GitHub:

Condividi tramite