Rychlý start: Použití klientské knihovny optického rozpoznávání znaků (OCR) nebo REST API

Pomocí klientské knihovny pro rozpoznávání OCR si můžete přečíst vytištěné a ručně psaný text z obrázku.

Referenční dokumentace | Zdrojový kód knihovny | Balíček (NuGet) | Ukázky

Požadavky

• Předplatné Azure – můžete ho vytvořit zdarma .
• Integrované vývojové prostředí (IDE) sady Visual Studio nebo aktuální verze .NET Core.
• Jakmile budete mít předplatné Azure, Počítačové zpracování obrazu v Azure Portal, abyste získali svůj klíč a koncový bod. Po nasazení klikněte na Přejít k prostředku.
  • K připojení aplikace k Počítačové zpracování obrazu službě budete potřebovat klíč a koncový bod z prostředku, který vytvoříte. Svůj klíč a koncový bod vložíte do níže uvedeného kódu později v rychlém startu.
  • K vyzkoušení služby můžete použít bezplatnou cenovou úroveň ( F0 ) a upgradovat ji později na placenou úroveň pro produkční prostředí.

Nastavení

Vytvoření nové aplikace v C#

dotnet new console -n computer-vision-quickstart

dotnet build

...
Build succeeded.
 0 Warning(s)
 0 Error(s)
...

dotnet add package Microsoft.Azure.CognitiveServices.Vision.ComputerVision --version 7.0.0

V adresáři projektu otevřete soubor program. cs v preferovaném editoru nebo integrovaném vývojovém prostředí (IDE).

Najít klíč předplatného a koncový bod

Přejděte na Azure Portal. Pokud se prostředek Počítačové zpracování obrazu, který jste vytvořili v části předpoklady , se úspěšně nasadil, klikněte v části Další kroky na tlačítko Přejít k prostředku . Klíč předplatného a koncový bod můžete najít na stránce klíč a koncový bod prostředku v části Správa prostředků.

Do třídy programu aplikace vytvořte proměnné pro klíč předplatného počítačové zpracování obrazu a koncový bod. Vložte klíč předplatného a koncový bod do následujícího kódu, kde je uvedený. Váš koncový bod Počítačové zpracování obrazu má formulář https://<your_computer_vision_resource_name>.cognitiveservices.azure.com/ .

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 subscription key and endpoint
        static string subscriptionKey = "PASTE_YOUR_COMPUTER_VISION_SUBSCRIPTION_KEY_HERE";
        static string endpoint = "PASTE_YOUR_COMPUTER_VISION_ENDPOINT_HERE";

V Main metodě aplikace přidejte volání metod používaných v rámci tohoto rychlého startu. Budete je vytvářet později.

ComputerVisionClient client = Authenticate(endpoint, subscriptionKey);

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

Objektový model

Následující třídy a rozhraní zpracovávají některé z hlavních funkcí sady OCR .NET SDK.

Příklady kódu

Tyto fragmenty kódu ukazují, jak provádět následující úlohy pomocí klientské knihovny pro rozpoznávání OCR pro .NET:

• Ověření klienta
• Číst vytištěné a ručně psaný text

Ověření klienta

V nové metodě ve třídě program vytvořte instanci klienta s vaším koncovým bodem a klíčem předplatného. Vytvořte objekt ApiKeyServiceClientCredentials s klíčem předplatného a použijte ho u svého koncového bodu k vytvoření objektu ComputerVisionClient .

/*
 * AUTHENTICATE
 * Creates a Computer Vision client used by each example.
 */
public static ComputerVisionClient Authenticate(string endpoint, string key)
{
    ComputerVisionClient client =
      new ComputerVisionClient(new ApiKeyServiceClientCredentials(key))
      { Endpoint = endpoint };
    return client;
}

Číst vytištěné a ručně psaný text

Služba OCR může číst viditelný text v obrázku a převést jej na datový proud znaků. Další informace o rozpoznávání textu naleznete v tématu Přehled optického rozpoznávání znaků (OCR) . Kód v této části používá nejnovější verzi sady počítačové zpracování obrazu SDK pro čtení 3,0 a definuje metodu, BatchReadFileUrl která používá objekt klienta ke zjištění a extrakci textu v obrázku.

Nastavit testovací image

Ve třídě program uložte odkaz na adresu URL obrázku, ze kterého chcete extrahovat text. Tento fragment kódu obsahuje vzorové obrázky pro tisk i rukopisný text.

private const string READ_TEXT_URL_IMAGE = "https://intelligentkioskstore.blob.core.windows.net/visionapi/suggestedphotos/3.png";

Volání rozhraní API pro čtení

Definujte novou metodu pro čtení textu. Přidejte následující kód, který volá metodu ReadAsync pro daný obrázek. Tato operace vrátí ID operace a spustí asynchronní proces pro čtení obsahu obrázku.

/*
 * READ FILE - URL 
 * Extracts text. 
 */
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);

Získat výsledky čtení

Potom Získejte ID operace vrácené voláním ReadAsync a použijte ji k dotazování služby na výsledky operace. Následující kód zkontroluje operaci, dokud nebudou vráceny výsledky. Pak zobrazí extrahovaná textová data do konzoly.

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

Zobrazit výsledky čtení

Přidejte následující kód, který analyzuje a zobrazí získaná textová data, a dokončete definici metody.

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

Spuštění aplikace

dotnet run

Vyčištění prostředků

Pokud chcete vyčistit a odebrat předplatné Cognitive Services, můžete prostředek nebo skupinu prostředků odstranit. Odstraněním skupiny prostředků se odstraní také všechny další prostředky, které jsou k ní přidružené.

• Azure Portal
• Azure CLI

Další kroky

V tomto rychlém startu jste zjistili, jak nainstalovat knihovnu klienta pro rozpoznávání OCR a použít rozhraní API pro čtení. V dalším kroku se dozvíte víc o funkcích rozhraní API pro čtení.

• Přehled rozpoznávání OCR
• Zdrojový kód pro tuto ukázku najdete na GitHubu.

Pomocí klientské knihovny pro rozpoznávání optických znaků si můžete přečíst vytištěné a ručně psaný text pomocí rozhraní API pro čtení.

Referenční dokumentace | Zdrojový kód knihovny | Balíček (PiPy) | Ukázky

Požadavky

• Předplatné Azure – můžete ho vytvořit zdarma .

• Python 3.x

  • Instalace Pythonu by měla zahrnovat PIP. Pomocí příkazu na příkazovém řádku můžete zjistit, jestli máte službu PIP nainstalovanou pip --version . Získejte PIP instalací nejnovější verze Pythonu.

• Jakmile budete mít předplatné Azure, Počítačové zpracování obrazu v Azure Portal, abyste získali svůj klíč a koncový bod. Po nasazení klikněte na Přejít k prostředku.

  • K připojení aplikace k Počítačové zpracování obrazu službě budete potřebovat klíč a koncový bod z prostředku, který vytvoříte. Svůj klíč a koncový bod vložíte do níže uvedeného kódu později v rychlém startu.
  • K vyzkoušení služby můžete použít bezplatnou cenovou úroveň ( F0 ) a upgradovat ji později na placenou úroveň pro produkční prostředí.

Nastavení

Instalace klientské knihovny

Klientskou knihovnu můžete nainstalovat pomocí nástroje:

pip install --upgrade azure-cognitiveservices-vision-computervision

Nainstalujte také knihovnu Pillow.

pip install pillow

Vytvoření nové aplikace v Pythonu

Vytvořte nový soubor Python — Quickstart-File.py, například. Pak ho otevřete v preferovaném editoru nebo integrovaném vývojovém prostředí (IDE).

Najít klíč předplatného a koncový bod

Přejděte na Azure Portal. Pokud se prostředek Počítačové zpracování obrazu, který jste vytvořili v části předpoklady , se úspěšně nasadil, klikněte v části Další kroky na tlačítko Přejít k prostředku . Klíč předplatného a koncový bod můžete najít na stránce klíč a koncový bod prostředku v části Správa prostředků.

Vytvořte proměnné pro klíč předplatného Počítačové zpracování obrazu a koncový bod. Vložte klíč předplatného a koncový bod do následujícího kódu, kde je uvedený. Váš koncový bod Počítačové zpracování obrazu má formulář https://<your_computer_vision_resource_name>.cognitiveservices.azure.com/ .

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 = "PASTE_YOUR_COMPUTER_VISION_SUBSCRIPTION_KEY_HERE"
endpoint = "PASTE_YOUR_COMPUTER_VISION_ENDPOINT_HERE"

Objektový model

Následující třídy a rozhraní zpracovávají některé z hlavních funkcí sady OCR Python SDK.

Příklady kódu

Tyto fragmenty kódu ukazují, jak provádět následující úlohy pomocí klientské knihovny OCR pro Python:

• Ověření klienta
• Číst vytištěné a ručně psaný text

Ověření klienta

Vytvořte instanci klienta s vaším koncovým bodem a klíčem. Vytvořte objekt CognitiveServicesCredentials s klíčem a použijte ho u svého koncového bodu k vytvoření objektu ComputerVisionClient .

computervision_client = ComputerVisionClient(endpoint, CognitiveServicesCredentials(subscription_key))

Číst vytištěné a ručně psaný text

Služba OCR může číst viditelný text v obrázku a převést jej na datový proud znaků. Provedete to ve dvou částech.

Volání rozhraní API pro čtení

Nejprve použijte následující kód pro volání metody Read pro daný obrázek. Tato operace vrátí ID operace a spustí asynchronní proces pro čtení obsahu obrázku.

'''
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://raw.githubusercontent.com/MicrosoftDocs/azure-docs/master/articles/cognitive-services/Computer-vision/Images/readsample.jpg"

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

Získat výsledky čtení

Potom Získejte ID operace vrácené voláním metody Read a použijte ji k dotazování služby na výsledky operace. Následující kód kontroluje operaci v intervalu 1 sekund, dokud nebudou vráceny výsledky. Pak zobrazí extrahovaná textová data do konzoly.

# 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()

Spuštění aplikace

Spusťte aplikaci pomocí python příkazu v souboru rychlého startu.

python quickstart-file.py

Vyčištění prostředků

Pokud chcete vyčistit a odebrat předplatné Cognitive Services, můžete prostředek nebo skupinu prostředků odstranit. Odstraněním skupiny prostředků se odstraní také všechny další prostředky, které jsou k ní přidružené.

• Azure Portal
• Azure CLI

Další kroky

V tomto rychlém startu jste zjistili, jak nainstalovat knihovnu klienta pro rozpoznávání OCR a použít rozhraní API pro čtení. V dalším kroku se dozvíte víc o funkcích rozhraní API pro čtení.

• Přehled rozpoznávání OCR
• Zdrojový kód pro tuto ukázku najdete na GitHub.

Ke čtení tištěných a ručně psaných textu na obrázcích použijte klientskou knihovnu pro optické rozpoznávání znaků.

Referenční dokumentace | Zdrojový kód knihovny | Artifact (Maven) | Ukázky

Požadavky

• Předplatné Azure – Vytvořte si ho zdarma.
• Aktuální verze sady Java Development Kit (JDK)
• Nástroj pro sestavení Gradlenebo jiný správce závislostí.
• Jakmile máte předplatné Azure, vytvořte prostředek Počítačové zpracování obrazu, který Počítačové zpracování obrazu ve službě Azure Portal a získejte bod. Po nasazení klikněte na Přejít k prostředku.
  • Klíč a koncový bod z prostředku, který vytvoříte, budete potřebovat pro připojení aplikace k Počítačové zpracování obrazu službě. Svůj klíč a koncový bod vložíte do kódu níže v pozdější části tohoto rychlého startu.
  • K vyzkoušejí služby můžete použít bezplatnou cenovou úroveň ( ) a později upgradovat F0 na placenou úroveň pro produkční prostředí.

Nastavení

Vytvoření nového projektu Gradle

V okně konzoly (například cmd, PowerShell nebo Bash) vytvořte nový adresář pro vaši aplikaci a přejděte do něj.

mkdir myapp && cd myapp

Z gradle init pracovního adresáře spusťte příkaz . Tento příkaz vytvoří základní soubory sestavení pro Gradle, včetně build.gradle.kts, který se používá za běhu k vytvoření a konfiguraci aplikace.

gradle init --type basic

Po zobrazení výzvy k výběru DSL vyberte Kotlin.

Instalace klientské knihovny

V tomto rychlém startu se používá správce závislostí Gradle. Klientskou knihovnu a informace o dalších správcích závislostí najdete v centrálním úložišti Maven.

Vyhledejte soubor build.gradle.kts a otevřete ho pomocí upřednostňovaného integrovaného vývojového prostředí nebo textového editoru. Potom zkopírujte následující konfiguraci sestavení. Tato konfigurace definuje projekt jako aplikaci Java, jejíž vstupním bodem je třída ComputerVisionQuickstart. Importuje knihovnu Počítačové zpracování obrazu.

plugins {
    java
    application
}
application { 
    mainClass.set("ComputerVisionQuickstart")
}
repositories {
    mavenCentral()
}
dependencies {
    implementation(group = "com.microsoft.azure.cognitiveservices", name = "azure-cognitiveservices-computervision", version = "1.0.6-beta")
}

Vytvoření souboru Java

Spuštěním následujícího příkazu v pracovním adresáři vytvořte zdrojovou složku projektu:

mkdir -p src/main/java

Přejděte do nové složky a vytvořte soubor s názvem ComputerVisionQuickstart.java. Otevřete ho v upřednostňovaném editoru nebo integrovaném vývojovém prostředí.)

Vyhledání klíče předplatného a koncového bodu

Přejděte na Azure Portal. Pokud je Počítačové zpracování obrazu prostředků, které jste vytvořili v části Požadavky úspěšně nasazené, klikněte na tlačítko Přejít k prostředku v části Další kroky. Klíč a koncový bod předplatného najdete na stránce klíče a koncového bodu prostředku v části správa prostředků.

Definujte třídu ComputerVisionQuickstart. Vytvořte proměnné pro klíč Počítačové zpracování obrazu předplatného a koncový bod. Vložte klíč předplatného a koncový bod do následujícího kódu, kde je uvedeno. Váš Počítačové zpracování obrazu koncový bod má tvar https://<your_computer_vision_resource_name>.cognitiveservices.azure.com/ .

import com.microsoft.azure.cognitiveservices.vision.computervision.*;
import com.microsoft.azure.cognitiveservices.vision.computervision.implementation.ComputerVisionImpl;
import com.microsoft.azure.cognitiveservices.vision.computervision.models.*;

import java.io.*;
import java.nio.file.Files;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

public class ComputerVisionQuickstart {

    static String subscriptionKey = "PASTE_YOUR_COMPUTER_VISION_SUBSCRIPTION_KEY_HERE";
    static String endpoint = "PASTE_YOUR_COMPUTER_VISION_ENDPOINT_HERE";

V hlavní metodě aplikace přidejte volání metod používaných v tomto rychlém startu. Později je definujete.

public static void main(String[] args) {
    
    System.out.println("\nAzure Cognitive Services Computer Vision - Java Quickstart Sample");

    // Create an authenticated Computer Vision client.
    ComputerVisionClient compVisClient = Authenticate(subscriptionKey, endpoint); 

    // Read from local file
    ReadFromFile(compVisClient);
}

Objektový model

Následující třídy a rozhraní se řídí některými hlavními funkcemi sady OCR Java SDK.

Příklady kódu

Tyto fragmenty kódu ukazují, jak pomocí klientské knihovny OCR pro Javu provádět následující úlohy:

• Ověření klienta
• Čtení tištěný a ručně psaného textu

Ověření klienta

V nové metodě vytvořte instanci objektu ComputerVisionClient s koncovým bodem a klíčem.

public static ComputerVisionClient Authenticate(String subscriptionKey, String endpoint){
    return ComputerVisionManager.authenticate(subscriptionKey).withEndpoint(endpoint);
}

Čtení tištěný a ručně psaného textu

Služba OCR může číst viditelný text na obrázku a převést ho na datový proud znaků. Tato část definuje metodu , která převezme místní cestu k souboru a vytiskne text obrázku ReadFromFile do konzoly.

Nastavení testovacího obrázku

Ve složce src/main/ vašeho projektu vytvořte složku resources/ a přidejte obrázek, ze které chcete číst text. Tady si můžete stáhnout ukázkový obrázek.

Pak do třídy ComputerVisionQuickstart přidejte následující definici metody. Změňte hodnotu tak, localFilePath aby odpovídala souboru obrázku.

/**
 * OCR with READ : Performs a Read Operation on a local image
 * @param client instantiated vision client
 * @param localFilePath local file path from which to perform the read operation against
 */
private static void ReadFromFile(ComputerVisionClient client) {
    System.out.println("-----------------------------------------------");
    
    String localFilePath = "src\\main\\resources\\myImage.png";
    System.out.println("Read with local file: " + localFilePath);

Volání rozhraní API pro čtení

Pak přidejte následující kód pro volání metody readInStreamWithServiceResponseAsync pro daný obrázek.

try {
    File rawImage = new File(localFilePath);
    byte[] localImageBytes = Files.readAllBytes(rawImage.toPath());

    // Cast Computer Vision to its implementation to expose the required methods
    ComputerVisionImpl vision = (ComputerVisionImpl) client.computerVision();

    // Read in remote image and response header
    ReadInStreamHeaders responseHeader =
            vision.readInStreamWithServiceResponseAsync(localImageBytes, null, null)
                .toBlocking()
                .single()
                .headers();

Následující blok kódu extrahuje ID operace z odpovědi volání Read. Pomocí tohoto ID s pomocná metoda vytiskne výsledky čtení textu do konzoly.

// Extract the operationLocation from the response header
String operationLocation = responseHeader.operationLocation();
System.out.println("Operation Location:" + operationLocation);

getAndPrintReadResult(vision, operationLocation);

Zavřete blok try/catch a definici metody.

    } catch (Exception e) {
        System.out.println(e.getMessage());
        e.printStackTrace();
    }
}

Získání výsledků čtení

Pak přidejte definici pro pomocná metoda. Tato metoda používá ID operace z předchozího kroku k dotazování operace čtení a získání výsledků OCR, jakmile jsou k dispozici.

/**
 * Polls for Read result and prints results to console
 * @param vision Computer Vision instance
 * @return operationLocation returned in the POST Read response header
 */
private static void getAndPrintReadResult(ComputerVision vision, String operationLocation) throws InterruptedException {
    System.out.println("Polling for Read results ...");

    // Extract OperationId from Operation Location
    String operationId = extractOperationIdFromOpLocation(operationLocation);

    boolean pollForResult = true;
    ReadOperationResult readResults = null;

    while (pollForResult) {
        // Poll for result every second
        Thread.sleep(1000);
        readResults = vision.getReadResult(UUID.fromString(operationId));

        // The results will no longer be null when the service has finished processing the request.
        if (readResults != null) {
            // Get request status
            OperationStatusCodes status = readResults.status();

            if (status == OperationStatusCodes.FAILED || status == OperationStatusCodes.SUCCEEDED) {
                pollForResult = false;
            }
        }
    }

Zbytek metody parsuje výsledky OCR a vytiskne je do konzoly.

    // Print read results, page per page
    for (ReadResult pageResult : readResults.analyzeResult().readResults()) {
        System.out.println("");
        System.out.println("Printing Read results for page " + pageResult.page());
        StringBuilder builder = new StringBuilder();

        for (Line line : pageResult.lines()) {
            builder.append(line.text());
            builder.append("\n");
        }

        System.out.println(builder.toString());
    }
}

Nakonec přidejte další pomocná metoda použitá výše, která extrahuje ID operace z počáteční odpovědi.

/**
 * Extracts the OperationId from a Operation-Location returned by the POST Read operation
 * @param operationLocation
 * @return operationId
 */
private static String extractOperationIdFromOpLocation(String operationLocation) {
    if (operationLocation != null && !operationLocation.isEmpty()) {
        String[] splits = operationLocation.split("/");

        if (splits != null && splits.length > 0) {
            return splits[splits.length - 1];
        }
    }
    throw new IllegalStateException("Something went wrong: Couldn't extract the operation id from the operation location");
}

Spuštění aplikace

Aplikaci můžete vytvořit pomocí:

gradle build

Spusťte aplikaci pomocí gradle run příkazu :

gradle run

Vyčištění prostředků

Pokud chcete vyčistit a odebrat předplatné Cognitive Services, můžete prostředek nebo skupinu prostředků odstranit. Odstraněním skupiny prostředků se odstraní také všechny ostatní prostředky, které jsou k ní přidružené.

• Azure Portal
• Azure CLI

Další kroky

V tomto rychlém startu jste zjistili, jak nainstalovat klientskou knihovnu OCR a používat rozhraní API pro čtení. Dále si přečtěte další informace o funkcích rozhraní API pro čtení.

• Přehled OCR
• Zdrojový kód této ukázky najdete na GitHubu.

Pomocí klientské knihovny pro rozpoznávání optických znaků si můžete přečíst vytištěné a ručně psaný text pomocí rozhraní API pro čtení.

Referenční dokumentace | Zdrojový kód knihovny | Balíček (npm) | Ukázky

Požadavky

• Předplatné Azure – můžete ho vytvořit zdarma .
• Aktuální verze Node.js
• Jakmile budete mít předplatné Azure, Počítačové zpracování obrazu v Azure Portal, abyste získali svůj klíč a koncový bod. Po nasazení klikněte na Přejít k prostředku.
  • K připojení aplikace k Počítačové zpracování obrazu službě budete potřebovat klíč a koncový bod z prostředku, který vytvoříte. Svůj klíč a koncový bod vložíte do níže uvedeného kódu později v rychlém startu.
  • K vyzkoušení služby můžete použít bezplatnou cenovou úroveň ( F0 ) a upgradovat ji později na placenou úroveň pro produkční prostředí.

Nastavení

Vytvoření nové aplikace Node.js

V okně konzoly (například cmd, PowerShell nebo bash) vytvořte nový adresář pro vaši aplikaci a přejděte na něj.

mkdir myapp && cd myapp

Spuštěním npm init příkazu vytvořte aplikaci uzlu se package.json souborem.

npm init

Instalace klientské knihovny

Nainstalujte ms-rest-azure balíček a @azure/cognitiveservices-computervision npm:

npm install @azure/cognitiveservices-computervision

Nainstalujte také modul Async:

npm install async

Soubor vaší aplikace package.json bude aktualizován pomocí závislostí.

Vytvořte nový soubor index.js a otevřete ho v textovém editoru.

Najít klíč předplatného a koncový bod

Přejděte na Azure Portal. Pokud se prostředek Počítačové zpracování obrazu, který jste vytvořili v části předpoklady , se úspěšně nasadil, klikněte v části Další kroky na tlačítko Přejít k prostředku . Klíč předplatného a koncový bod můžete najít na stránce klíč a koncový bod prostředku v části Správa prostředků.

Vytvořte proměnné pro klíč předplatného Počítačové zpracování obrazu a koncový bod. Vložte klíč předplatného a koncový bod do následujícího kódu, kde je uvedený. Váš koncový bod Počítačové zpracování obrazu má formulář https://<your_computer_vision_resource_name>.cognitiveservices.azure.com/ .

'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 = 'PASTE_YOUR_COMPUTER_VISION_SUBSCRIPTION_KEY_HERE';
const endpoint = 'PASTE_YOUR_COMPUTER_VISION_ENDPOINT_HERE';

Objektový model

Následující třídy a rozhraní zpracovávají některé z hlavních funkcí sady OCR Node.js SDK.

Příklady kódu

Tyto fragmenty kódu ukazují, jak provádět následující úlohy pomocí klientské knihovny OCR pro Node.js:

• Ověření klienta
• Číst vytištěné a ručně psaný text

Ověření klienta

Vytvořte instanci klienta s vaším koncovým bodem a klíčem. Vytvořte objekt ApiKeyCredentials s klíčem a koncovým bodem a použijte ho k vytvoření objektu ComputerVisionClient .

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

Pak definujte funkci computerVision a deklarujte asynchronní řadu s primární funkcí a funkcí zpětného volání. Na konci skriptu dokončete tuto definici funkce a zavolejte ji.

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

Číst vytištěné a ručně psaný text

Služba OCR může extrahovat viditelný text v obrázku a převést jej na datový proud. Tato ukázka používá operace čtení.

Nastavení testovacích imagí

Uložte odkaz na adresu URL obrázků, ze kterých chcete extrahovat text.

// 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://moderatorsampleimages.blob.core.windows.net/samples/sample2.jpg';
const multiLingualTextURL = 'https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/MultiLingual.png';
const mixedMultiPagePDFURL = 'https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/MultiPageHandwrittenForm.pdf';

Volání rozhraní API pro čtení

Definujte následující pole ve funkci, aby se načetly hodnoty stavu volání metody Read.

// Status strings returned from Read API. NOTE: CASING IS SIGNIFICANT.
// Before Read 3.0, these are "Succeeded" and "Failed"
const STATUS_SUCCEEDED = "succeeded";
const STATUS_FAILED = "failed"

Přidejte následující kód, který volá readTextFromURL funkci pro dané obrázky.

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

// Recognize multi-lingual text in a PNG from a URL
console.log('\nRead printed multi-lingual text in a PNG from URL...', multiLingualTextURL.split('/').pop());
const multiLingualResult = await readTextFromURL(computerVisionClient, multiLingualTextURL);
printRecText(multiLingualResult);

// Recognize printed text and handwritten text in a PDF from a URL
console.log('\nRead printed and handwritten text from a PDF from URL...', mixedMultiPagePDFURL.split('/').pop());
const mixedPdfResult = await readTextFromURL(computerVisionClient, mixedMultiPagePDFURL);
printRecText(mixedPdfResult);

Definujte readTextFromURL funkci. Volá metodu Read objektu klienta, který vrací ID operace a spustí asynchronní proces pro čtení obsahu obrázku. Pak pomocí ID operace zkontroluje stav operace, dokud nebudou vráceny výsledky. Vrátí extrahované výsledky.

// 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 !== 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.
}

Pak definujte pomocnou funkci printRecText , která vytiskne výsledky operací čtení do konzoly.

// 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.'); }
  }
}

Zavřít funkci

Ukončete computerVision funkci a zavolejte ji.

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

computerVision();

Spuštění aplikace

Spusťte aplikaci pomocí node příkazu v souboru rychlého startu.

node index.js

Vyčištění prostředků

Pokud chcete vyčistit a odebrat předplatné Cognitive Services, můžete prostředek nebo skupinu prostředků odstranit. Odstraněním skupiny prostředků se odstraní také všechny další prostředky, které jsou k ní přidružené.

• Azure Portal
• Azure CLI

Další kroky

V tomto rychlém startu jste zjistili, jak nainstalovat knihovnu klienta pro rozpoznávání OCR a použít rozhraní API pro čtení. V dalším kroku se dozvíte víc o funkcích rozhraní API pro čtení.

• Přehled rozpoznávání OCR
• Zdrojový kód pro tuto ukázku najdete na GitHub.

Pomocí klientské knihovny pro rozpoznávání OCR si můžete přečíst vytištěný a rukou psaný text z obrázků.

Referenční dokumentace | Zdrojový kód knihovny | Balíček

Požadavky

• Předplatné Azure – můžete ho vytvořit zdarma .
• Nejnovější verze nástroje Přejít
• Jakmile budete mít předplatné Azure, Počítačové zpracování obrazu v Azure Portal, abyste získali svůj klíč a koncový bod. Po nasazení klikněte na Přejít k prostředku.
  • K připojení aplikace k Počítačové zpracování obrazu službě budete potřebovat klíč a koncový bod z prostředku, který vytvoříte. Svůj klíč a koncový bod vložíte do níže uvedeného kódu později v rychlém startu.
  • K vyzkoušení služby můžete použít bezplatnou cenovou úroveň ( F0 ) a upgradovat ji později na placenou úroveň pro produkční prostředí.

Nastavení

Vytvořit adresář projektu přejít

V okně konzoly (cmd, PowerShell, terminál, bash) vytvořte nový pracovní prostor pro projekt na cestách s názvem my-app a přejděte na něj.

mkdir -p my-app/{src, bin, pkg}  
cd my-app

Váš pracovní prostor bude obsahovat tři složky:

• Src – tento adresář bude obsahovat zdrojový kód a balíčky. Všechny balíčky nainstalované pomocí go get příkazu se budou nacházet v tomto adresáři.
• pkg – tento adresář bude obsahovat kompilované objekty balíčku pro přechod. Všechny tyto soubory mají .a rozšíření.
• bin – tento adresář bude obsahovat binární spustitelné soubory, které se vytvoří při spuštění go install .

Instalace klientské knihovny pro přejít

Dále nainstalujte klientskou knihovnu pro přejít:

go get -u https://github.com/Azure/azure-sdk-for-go/tree/master/services/cognitiveservices/v2.1/computervision

nebo pokud používáte DEP, v rámci vašeho úložiště úložišť:

dep ensure -add https://github.com/Azure/azure-sdk-for-go/tree/master/services/cognitiveservices/v2.1/computervision

Vytvoření aplikace v cestách

Dále vytvořte soubor v adresáři Src s názvem sample-app.go :

cd src
touch sample-app.go

Otevřete sample-app.go v upřednostňovaném integrovaném vývojovém prostředí (IDE) nebo textovém editoru.

Deklarujete kontext v kořenovém adresáři vašeho skriptu. Tento objekt budete potřebovat ke spuštění většiny Počítačové zpracování obrazu volání funkcí.

Najít klíč předplatného a koncový bod

Přejděte na Azure Portal. Pokud se prostředek Počítačové zpracování obrazu, který jste vytvořili v části předpoklady , se úspěšně nasadil, klikněte v části Další kroky na tlačítko Přejít k prostředku . Klíč předplatného a koncový bod můžete najít na stránce klíč a koncový bod prostředku v části Správa prostředků.

Vytvořte proměnné pro klíč předplatného Počítačové zpracování obrazu a koncový bod. Vložte klíč předplatného a koncový bod do následujícího kódu, kde je uvedený. Váš koncový bod Počítačové zpracování obrazu má formulář https://<your_computer_vision_resource_name>.cognitiveservices.azure.com/ .

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "github.com/Azure/azure-sdk-for-go/services/cognitiveservices/v2.0/computervision"
    "github.com/Azure/go-autorest/autorest"
    "io"
    "log"
    "os"
    "strings"
    "time"
)

// Declare global so don't have to pass it to all of the tasks.
var computerVisionContext context.Context

func main() {
    computerVisionKey := "PASTE_YOUR_COMPUTER_VISION_SUBSCRIPTION_KEY_HERE"
    endpointURL := "PASTE_YOUR_COMPUTER_VISION_ENDPOINT_HERE"

V dalším kroku začnete přidávat kód pro provádění různých operací OCR.

Objektový model

Následující třídy a rozhraní zpracovávají některé z hlavních funkcí sady SDK pro rozpoznávání OCR.

Příklady kódu

Tyto fragmenty kódu ukazují, jak provádět následující úlohy pomocí klientské knihovny OCR pro funkci přejít:

• Ověření klienta
• Číst vytištěné a ručně psaný text

Ověření klienta

Vytvořte main funkci a přidejte do ní následující kód, který vytvoří instanci klienta s vaším koncovým bodem a klíčem.

/*  
 * Configure the Computer Vision client
 */
computerVisionClient := computervision.New(endpointURL);
computerVisionClient.Authorizer = autorest.NewCognitiveServicesAuthorizer(computerVisionKey)

computerVisionContext = context.Background()
/*
 * END - Configure the Computer Vision client
 */

Číst vytištěné a ručně psaný text

Služba OCR může číst viditelný text v obrázku a převést jej na datový proud znaků. Kód v této části definuje funkci, RecognizeTextReadAPIRemoteImage která používá objekt klienta k detekci a extrakci vytištěného nebo rukopisného textu v obrázku.

Přidejte odkaz na vzorový obrázek a volání funkce ve main funkci.

// Analyze text in an image, remote
BatchReadFileRemoteImage(computerVisionClient, printedImageURL)

Volání rozhraní API pro čtení

Definujte novou funkci pro čtení textu, RecognizeTextReadAPIRemoteImage . Přidejte následující kód, který volá metodu BatchReadFile pro daný obrázek. Tato metoda vrátí ID operace a spustí asynchronní proces pro čtení obsahu obrázku.

func BatchReadFileRemoteImage(client computervision.BaseClient, remoteImageURL string) {
    fmt.Println("-----------------------------------------")
    fmt.Println("BATCH READ FILE - remote")
    fmt.Println()
    var remoteImage computervision.ImageURL
    remoteImage.URL = &remoteImageURL

    // The response contains a field called "Operation-Location", 
    // which is a URL with an ID that you'll use for GetReadOperationResult to access OCR results.
    textHeaders, err := client.BatchReadFile(computerVisionContext, remoteImage)
    if err != nil { log.Fatal(err) }

    // Use ExtractHeader from the autorest library to get the Operation-Location URL
    operationLocation := autorest.ExtractHeaderValue("Operation-Location", textHeaders.Response)

    numberOfCharsInOperationId := 36
    operationId := string(operationLocation[len(operationLocation)-numberOfCharsInOperationId : len(operationLocation)])

Získat výsledky čtení

Potom Získejte ID operace vrácené voláním BatchReadFile a použijte ji s metodou GetReadOperationResult pro dotazování služby na výsledky operace. Následující kód kontroluje operaci v intervalu 1 sekund, dokud nebudou vráceny výsledky. Pak zobrazí extrahovaná textová data do konzoly.

readOperationResult, err := client.GetReadOperationResult(computerVisionContext, operationId)
if err != nil { log.Fatal(err) }

// Wait for the operation to complete.
i := 0
maxRetries := 10

fmt.Println("Recognizing text in a remote image with the batch Read API ...")
for readOperationResult.Status != computervision.Failed &&
        readOperationResult.Status != computervision.Succeeded {
    if i >= maxRetries {
        break
    }
    i++

    fmt.Printf("Server status: %v, waiting %v seconds...\n", readOperationResult.Status, i)
    time.Sleep(1 * time.Second)

    readOperationResult, err = client.GetReadOperationResult(computerVisionContext, operationId)
    if err != nil { log.Fatal(err) }
}

Zobrazit výsledky čtení

Přidejte následující kód pro analýzu a zobrazení načtených textových dat a dokončete definici funkce.

// Display the results.
fmt.Println()
for _, recResult := range *(readOperationResult.RecognitionResults) {
    for _, line := range *recResult.Lines {
        fmt.Println(*line.Text)
    }
}

Spuštění aplikace

Spusťte aplikaci z adresáře aplikace pomocí go run příkazu.

go run sample-app.go

Vyčištění prostředků

Pokud chcete vyčistit a odebrat předplatné Cognitive Services, můžete prostředek nebo skupinu prostředků odstranit. Odstraněním skupiny prostředků se odstraní také všechny další prostředky, které jsou k ní přidružené.

• Azure Portal
• Azure CLI

Další kroky

V tomto rychlém startu jste zjistili, jak nainstalovat knihovnu klienta pro rozpoznávání OCR a použít rozhraní API pro čtení. V dalším kroku se dozvíte víc o funkcích rozhraní API pro čtení.

• Přehled rozpoznávání OCR
• Zdrojový kód pro tuto ukázku najdete na GitHub.

Použijte REST API optického rozpoznávání znaků pro čtení vytištěného a rukopisného textu.

Požadavky

• Předplatné Azure – můžete ho vytvořit zdarma .
• Jakmile budete mít předplatné Azure, Počítačové zpracování obrazu v Azure Portal, abyste získali svůj klíč a koncový bod. Po nasazení klikněte na Přejít k prostředku.
  • K připojení aplikace k Počítačové zpracování obrazu službě budete potřebovat klíč a koncový bod z prostředku, který vytvoříte. Svůj klíč a koncový bod vložíte do níže uvedeného kódu později v rychlém startu.
  • K vyzkoušení služby můžete použít bezplatnou cenovou úroveň ( F0 ) a upgradovat ji později na placenou úroveň pro produkční prostředí.
• nainstalovaná složená závorka

Vyjmutí vytištěného a rukopisného textu

Služba OCR může extrahovat viditelný text v obrázku nebo dokumentu a převést ho do datového proudu znaků. Další informace o extrakci textu naleznete v tématu Přehled optického rozpoznávání znaků (OCR).

Volání rozhraní API pro čtení

Pokud chcete vytvořit a spustit ukázku, postupujte takto:

1. Zkopírujte do textového editoru následující příkaz.
2. Proveďte v příkazu na příslušných místech následující změny:
   1. Hodnotu <subscriptionKey> nahraďte klíčem předplatného.
   2. Nahraďte první část adresy URL požadavku ( westcentralus ) textem ve vaší vlastní adrese URL koncového bodu.

      Poznámka

      Nové prostředky vytvořené po 1. červenci 2019 budou používat názvy vlastních subdomén. Další informace a úplný seznam regionálních koncových bodů najdete v tématu názvy vlastních subdomén pro Cognitive Services.

   3. Volitelně můžete změnit adresu URL obrázku v textu požadavku (https://upload.wikimedia.org/wikipedia/commons/thumb/a/af/Atomist_quote_from_Democritus.png/338px-Atomist_quote_from_Democritus.png\) na adresu URL jiného obrázku, který se má analyzovat.
3. Otevřete okno příkazového řádku.
4. Vložte příkaz z textového editoru do okna příkazového řádku a pak příkaz spusťte.

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://upload.wikimedia.org/wikipedia/commons/thumb/a/af/Atomist_quote_from_Democritus.png/338px-Atomist_quote_from_Democritus.png\"}"

Odpověď bude obsahovat Operation-Location hlavičku, jejíž hodnota je jedinečná adresa URL. Tuto adresu URL použijete k dotazování na výsledky operace čtení. Platnost adresy URL vyprší během 48 hodin.

Jak používat funkce verze Preview

Jazyky a funkce ve verzi Preview najdete v tématu Určení verze modelu pro použití nejnovější verze Preview. Model verze Preview obsahuje vylepšení v aktuálně GA jazycích a funkcích.

Získat výsledky čtení

1. Zkopírujte následující příkaz do textového editoru.
2. Adresu URL nahraďte Operation-Location hodnotou, kterou jste zkopírovali v předchozím kroku.
3. Proveďte v příkazu na příslušných místech následující změny:
   1. Hodnotu <subscriptionKey> nahraďte klíčem předplatného.
4. Otevřete okno příkazového řádku.
5. Vložte příkaz z textového editoru do okna příkazového řádku a pak příkaz spusťte.

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

Prozkoumání odpovědi

Úspěšná odpověď se vrátí ve formátu JSON. Ukázková aplikace provede analýzu a zobrazí úspěšnou odpověď v okně příkazového řádku, podobně jako v následujícím příkladu:

{
  "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
              }
            ]
          }
        ]
      }
    ]
  }
}

Další kroky

V tomto rychlém startu jste zjistili, jak volat REST API pro čtení. V dalším kroku se dozvíte víc o funkcích rozhraní API pro čtení.

• Přehled rozpoznávání OCR