Snabbstart: Identifiera digitala pennanteckningar med REST API för handskriftsigenkänning och Java

Artikel
08/24/2020

Anteckning

API:et för handskriftsigenkänning har avslutat förhandsversionen den 26 augusti 2020. Om du har befintliga resurser för handskriftsigenkänning kan du fortsätta att använda dem tills tjänsten har dragits tillbaka helt den 31 januari 2021.

Använd den här snabbstarten för att börja använda API:et för handskriftsigenkänning på digitala pennstreck. Det här Java-programmet skickar en API-begäran som innehåller JSON-formaterade pennstrecksdata och hämtar svaret.

Även om det här programmet är skrivet i Java, är API:et en RESTful-webbtjänst som är kompatibel med de flesta programmeringsspråk.

Vanligtvis anropar du API:et från en digital pennanteckningsapp. Den här snabbstarten skickar pennstrecksdata för följande handskrivna exempel från en JSON-fil.

en bild av handskriven text

Källkoden för den här snabbstarten finns på GitHub.

Förutsättningar

Java™ Development Kit (JDK) 7 eller senare.
Importera dessa bibliotek från Maven-lagringsplatsen
- JSON i Java-paket
- Apache HttpClient-paket
Exempeldata för pennstreck för den här snabbstarten finns på GitHub.

Skapa en resurs för handskriftsigenkänning

Anteckning

Slutpunkter för resurser som skapats efter den 1 juli 2019 använder det anpassade underdomänformatet som visas nedan. Mer information och en fullständig lista över regionala slutpunkter finns i Anpassade underdomännamn för Cognitive Services.

Azure Cognitive Services representeras av Azure-resurser som du prenumererar på. Skapa en resurs för handskriftsigenkänning med hjälp av Azure Portal.

När du har skapat en resurs hämtar du slutpunkten och nyckeln genom att öppna resursen på Azure Portal och klicka på Snabbstart.

Skapa två miljövariabler:

INK_RECOGNITION_SUBSCRIPTION_KEY – Prenumerationsnyckeln för att autentisera dina begäranden.
INK_RECOGNITION_ENDPOINT – Slutpunkten för resursen. Resultatet ser ut så här:
https://<your-custom-subdomain>.api.cognitive.microsoft.com

Skapa ett nytt program

Skapa ett nytt Java-projekt i valfri IDE eller redigeringsprogram och importera följande bibliotek.

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;

Skapa variabler för din prenumerationsnyckel, slutpunkt och JSON-fil. Slutpunkten läggs senare till i URI:n för handskriftsigenkänning.

// 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";

Skapa en funktion för att skicka begäranden

Skapa en ny funktion med namnet sendRequest() som tar variablerna som skapades ovan. Utför sedan följande steg.
Skapa ett CloseableHttpClient objekt som kan skicka begäranden till API:et. Skicka begäran till ett begärandeobjekt HttpPut genom att kombinera slutpunkten och URL:en för handskriftsigenkänning.
Använd funktionen för begäran för att ange Content-Type huvudet till application/jsonoch lägga till din prenumerationsnyckel setHeader() i Ocp-Apim-Subscription-Key rubriken.
Använd funktionen för begäran setEntity() till de data som ska skickas.
Använd klientens execute() funktion för att skicka begäran och spara den i ett CloseableHttpResponse -objekt.

Skapa ett HttpEntity -objekt för att lagra svarsinnehållet. Hämta innehållet med getEntity(). Om svaret inte är tomt returnerar du det.

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;
}

Skicka en begäran om pennanteckningsigenkänning

Skapa en metod med namnet recognizeInk() för att identifiera dina pennstrecksdata. Anropa metoden sendRequest() som skapades ovan med din slutpunkt, URL, prenumerationsnyckel och json-data. Hämta resultatet och skriv ut det till konsolen.

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();
    }  
}

Läs in dina digitala pennanteckningsdata och skicka begäran

I huvudmetoden för ditt program läser du i JSON-filen som innehåller de data som ska läggas till i begärandena.

Anropa funktionen för pennanteckningsigenkänning som skapades ovan.

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

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

Kör programmet och visa svaret

Kör appen. Ett lyckat svar returneras i JSON-format. Du kan också hitta JSON-svaret på GitHub.

Nästa steg

Referens för REST-API

Om du vill se hur API:et för pennanteckning fungerar i en digital pennanteckningsapp kan du ta en titt på följande exempelprogram på GitHub: